V8. ASM-2-WASM. Migrates asm-wasm-builder to the new asm-typer.

src/asmjs/asm-typer.cc

 // Copyright 2016 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/asmjs/asm-typer.h"
 
 #include <limits>
 #include <string>
 
 #include "src/v8.h"
@@ skipping 30 matching lines @@
     }                                                             \
                                                                   \
     if (result == AsmType::None()) {                              \
       return AsmType::None();                                     \
     }                                                             \
   } while (false)
 
 namespace v8 {
 namespace internal {
 namespace wasm {
+namespace {
+static const uint32_t LargestFixNum = std::numeric_limits<int32_t>::max();
+}  // namespace
 
 using v8::internal::AstNode;
 using v8::internal::GetCurrentStackPosition;
 
 // ----------------------------------------------------------------------------
 // Implementation of AsmTyper::FlattenedStatements
 
 AsmTyper::FlattenedStatements::FlattenedStatements(Zone* zone,
                                                    ZoneList<Statement*>* s)
     : context_stack_(zone) {
@@ skipping 54 matching lines @@
       forward_definitions_(zone),
       stdlib_types_(zone),
       stdlib_math_types_(zone),
       global_scope_(ZoneHashMap::PointersMatch,
                     ZoneHashMap::kDefaultHashMapCapacity,
                     ZoneAllocationPolicy(zone)),
       local_scope_(ZoneHashMap::PointersMatch,
                    ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
       stack_limit_(isolate->stack_guard()->real_climit()),
-      node_types_(zone_) {
+      node_types_(zone_),
+      fround_type_(AsmType::FroundType(zone_)) {
   InitializeStdlib();
   module_info_.set_standard_member(kModule);
 }
 
 namespace {
 bool ValidAsmIdentifier(Handle<String> name) {
   static const char* kInvalidAsmNames[] = {"eval", "arguments"};
 
   for (size_t ii = 0; ii < arraysize(kInvalidAsmNames); ++ii) {
     if (strcmp(name->ToCString().get(), kInvalidAsmNames[ii]) == 0) {
@@ skipping 22 matching lines @@
   auto* s = AsmType::Signed();
   auto* s2s = AsmType::Function(zone_, s);
   s2s->AsFunctionType()->AddArgument(s);
 
   auto* i = AsmType::Int();
   auto* ii2s = AsmType::Function(zone_, s);
   ii2s->AsFunctionType()->AddArgument(i);
   ii2s->AsFunctionType()->AddArgument(i);
 
   auto* minmax_d = AsmType::MinMaxType(zone_, d, d);
+  // *VIOLATION* The float variant is not part of the spec, but firefox accepts
+  // it.
+  auto* minmax_f = AsmType::MinMaxType(zone_, f, f);
   auto* minmax_i = AsmType::MinMaxType(zone_, s, i);
   auto* minmax = AsmType::OverloadedFunction(zone_);
   minmax->AsOverloadedFunctionType()->AddOverload(minmax_i);
+  minmax->AsOverloadedFunctionType()->AddOverload(minmax_f);
   minmax->AsOverloadedFunctionType()->AddOverload(minmax_d);
 
-  auto* fround = AsmType::FroundType(zone_);
+  auto* fround = fround_type_;
 
   auto* abs = AsmType::OverloadedFunction(zone_);
   abs->AsOverloadedFunctionType()->AddOverload(s2s);
   abs->AsOverloadedFunctionType()->AddOverload(dq2d);
   abs->AsOverloadedFunctionType()->AddOverload(fq2f);
 
   auto* ceil = AsmType::OverloadedFunction(zone_);
   ceil->AsOverloadedFunctionType()->AddOverload(dq2d);
   ceil->AsOverloadedFunctionType()->AddOverload(fq2f);
 
@@ skipping 171 matching lines @@
   if (entry->value != nullptr) {
     return false;
   }
 
   entry->value = info;
   return true;
 }
 
 void AsmTyper::SetTypeOf(AstNode* node, AsmType* type) {
   DCHECK_NE(type, AsmType::None());
-  auto** node_type = &node_types_[node];
-  DCHECK(*node_type == nullptr);
-  *node_type = type;
+  DCHECK(node_types_.find(node) == node_types_.end());
+  node_types_.insert(std::make_pair(node, type));
 }
 
 AsmType* AsmTyper::TypeOf(AstNode* node) const {
   auto node_type_iter = node_types_.find(node);
-  if (node_type_iter == node_types_.end()) {
-    return AsmType::None();
+  if (node_type_iter != node_types_.end()) {
+    return node_type_iter->second;
   }
-  return node_type_iter->second;
+
+  // Sometimes literal nodes are not added to the node_type_ map simply because
+  // their are not visited with ValidateExpression().
+  if (auto* literal = node->AsLiteral()) {
+    if (literal->raw_value()->ContainsDot()) {
+      return AsmType::Double();
+    }
+    uint32_t u;
+    if (literal->value()->ToUint32(&u)) {
+      if (u > LargestFixNum) {
+        return AsmType::Unsigned();
+      }
+      return AsmType::FixNum();
+    }
+    int32_t i;
+    if (literal->value()->ToInt32(&i)) {
+      return AsmType::Signed();
+    }
+  }
+
+  return AsmType::None();
 }
 
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(Variable* var) {
   auto* var_info = Lookup(var);
   if (var_info == nullptr) {
     return kNone;
   }
   return var_info->standard_member();
 }
 
@@ skipping 214 matching lines @@
   auto* target_variable = target->AsVariableProxy()->var();
   auto* target_info = Lookup(target_variable);
 
   if (target_info != nullptr) {
     FAIL(target, "Redefined global variable.");
   }
 
   auto* value = assign->value();
   // Not all types of assignment are allowed by asm.js. See
   // 5.5 Global Variable Type Annotations.
+  bool global_variable = false;
   if (value->IsLiteral() || value->IsCall()) {
     AsmType* type = nullptr;
     RECURSE(type = VariableTypeAnnotations(value));
     target_info = new (zone_) VariableInfo(type);
     target_info->set_mutability(VariableInfo::kMutableGlobal);
+    global_variable = true;
   } else if (value->IsProperty()) {
     target_info = ImportLookup(value->AsProperty());
     if (target_info == nullptr) {
       FAIL(assign, "Invalid import.");
     }
     CHECK(target_info->mutability() == VariableInfo::kImmutableGlobal);
     if (!target_info->IsFFI()) {
       target_info = target_info->Clone(zone_);
     } else {
       // create a new target info that represents a foreign variable.
@@ skipping 57 matching lines @@
 
   if (!ValidAsmIdentifier(target_variable->name())) {
     FAIL(target, "Invalid asm.js identifier in global variable.");
   }
 
   if (!AddGlobal(target_variable, target_info)) {
     FAIL(assign, "Redeclared global identifier.");
   }
 
   DCHECK(target_info->type() != AsmType::None());
+  if (!global_variable) {
+    // Global variables have their types set in VariableTypeAnnotations.
+    SetTypeOf(value, target_info->type());
+  }
+  SetTypeOf(assign, target_info->type());
+  SetTypeOf(target, target_info->type());
   return target_info->type();
 }
 
 // 6.2 ValidateExport
 AsmType* AsmTyper::ExportType(VariableProxy* fun_export) {
   auto* fun_info = Lookup(fun_export->var());
   if (fun_info == nullptr) {
     FAIL(fun_export, "Undefined identifier in asm.js module export.");
   }
 
@@ skipping 121 matching lines @@
     target_info = new (zone_) VariableInfo(AsmType::FunctionTableType(
         zone_, pointers->length(), table_element_type));
     target_info->set_mutability(VariableInfo::kImmutableGlobal);
     if (!ValidAsmIdentifier(target_variable->name())) {
       FAIL(target, "Invalid asm.js identifier in function table name.");
     }
     if (!AddGlobal(target_variable, target_info)) {
       DCHECK(false);
       FAIL(assign, "Redeclared global identifier in function table name.");
     }
+    SetTypeOf(value, target_info->type());
     return target_info->type();
   }
 
   auto* target_info_table = target_info->type()->AsFunctionTableType();
   if (target_info_table == nullptr) {
     FAIL(assign, "Identifier redefined as function pointer table.");
   }
 
   if (!target_info->missing_definition()) {
     FAIL(assign, "Identifier redefined (function table name).");
   }
 
   if (target_info_table->length() != pointers->length()) {
     FAIL(assign, "Function table size mismatch.");
   }
 
   auto* function_type = callable_type->AsFunctionType();
   if (target_info_table->ValidateCall(function_type->ReturnType(),
                                       function_type->Arguments()) ==
       AsmType::None()) {
     FAIL(assign, "Function table initializer does not match previous type.");
   }
 
   target_info->MarkDefined();
-  DCHECK(target_info->type() == AsmType::None());
+  DCHECK(target_info->type() != AsmType::None());
   SetTypeOf(value, target_info->type());
 
   return target_info->type();
 }
 
 // 6.4 ValidateFunction
 AsmType* AsmTyper::ValidateFunction(FunctionDeclaration* fun_decl) {
   FunctionScope _(this);
 
   // Extract parameter types.
@@ skipping 41 matching lines @@
     auto* param_info = new (zone_) VariableInfo(type);
     param_info->set_mutability(VariableInfo::kLocal);
     if (!ValidAsmIdentifier(proxy->name())) {
       FAIL(proxy, "Invalid asm.js identifier in parameter name.");
     }
 
     if (!AddLocal(param, param_info)) {
       FAIL(proxy, "Redeclared parameter.");
     }
     parameter_types.push_back(type);
+    SetTypeOf(proxy, type);
+    SetTypeOf(expr, type);
   }
 
   if (annotated_parameters != fun->parameter_count()) {
     FAIL(fun_decl, "Incorrect parameter type annotations.");
   }
 
   // 5.3 Function type annotations
   //     * locals
   for (; current; current = iter.Next()) {
     auto* initializer = ExtractInitializerExpression(current);
@@ skipping 16 matching lines @@
     RECURSE(type = VariableTypeAnnotations(initializer->value()));
     auto* local_info = new (zone_) VariableInfo(type);
     local_info->set_mutability(VariableInfo::kLocal);
     if (!ValidAsmIdentifier(local->name())) {
       FAIL(local, "Invalid asm.js identifier in local variable.");
     }
 
     if (!AddLocal(local->var(), local_info)) {
       FAIL(initializer, "Redeclared local.");
     }
+
+    SetTypeOf(local, type);
+    SetTypeOf(initializer, type);
   }
 
   // 5.2 Return Type Annotations
   // *VIOLATION* we peel blocks to find the last statement in the asm module
   // because the parser may introduce synthetic blocks.
   ZoneList<Statement*>* statements = fun->body();
 
   do {
     if (statements->length() == 0) {
       return_type_ = AsmType::Void();
@@ skipping 46 matching lines @@
   fun_info->set_mutability(VariableInfo::kImmutableGlobal);
   auto* old_fun_type = Lookup(fun_var);
   if (old_fun_type == nullptr) {
     if (!ValidAsmIdentifier(fun_var->name())) {
       FAIL(fun_decl_proxy, "Invalid asm.js identifier in function name.");
     }
     if (!AddGlobal(fun_var, fun_info)) {
       DCHECK(false);
       FAIL(fun_decl, "Redeclared global identifier.");
     }
+
+    SetTypeOf(fun, fun_type);
     return fun_type;
   }
 
   // Not necessarily an error -- fun_decl might have been used before being
   // defined. If that's the case, then the type in the global environment must
   // be the same as the type inferred by the parameter/return type annotations.
   auto* old_fun_callable = old_fun_type->type()->AsCallableType();
   if (old_fun_callable == nullptr) {
     FAIL(fun_decl, "Identifier redefined as function.");
   }
@@ skipping 183 matching lines @@
   }
 
   bool has_default = false;
 
   ZoneSet<int32_t> cases_seen(zone_);
   for (auto* a_case : *stmt->cases()) {
     if (a_case->is_default()) {
       CHECK(!has_default);
       RECURSE(ValidateDefault(a_case));
       has_default = true;
+      continue;
     }
 
     int32_t case_lbl;
     RECURSE(ValidateCase(a_case, &case_lbl));
     auto case_lbl_pos = cases_seen.find(case_lbl);
     if (case_lbl_pos != cases_seen.end() && *case_lbl_pos == case_lbl) {
       FAIL(a_case, "Duplicated case label.");
     }
     cases_seen.insert(case_lbl);
   }
@@ skipping 123 matching lines @@
   // *VIOLATION* The parser replaces uses of +x with x*1.0.
   if (binop->op() != Token::MUL) {
     return false;
   }
 
   auto* right_as_literal = binop->right()->AsLiteral();
   if (right_as_literal == nullptr) {
     return false;
   }
 
-  return right_as_literal->raw_value()->ContainsDot() &&
+  return !right_as_literal->raw_value()->ContainsDot() &&
          right_as_literal->raw_value()->AsNumber() == -1.0;
 }
 }  // namespace
 
 AsmType* AsmTyper::ValidateBinaryOperation(BinaryOperation* expr) {
 #define UNOP_OVERLOAD(Src, Dest)          \
   do {                                    \
     if (left_type->IsA(AsmType::Src())) { \
       return AsmType::Dest();             \
     }                                     \
   } while (0)
 
   switch (expr->op()) {
     default:
       FAIL(expr, "Invalid asm.js binary expression.");
     case Token::COMMA:
       return ValidateCommaExpression(expr);
     case Token::MUL:
       if (IsDoubleAnnotation(expr)) {
         // *VIOLATION* We can't be 100% sure this really IS a unary + in the asm
         // source so we have to be lenient, and treat this as a unary +.
         if (auto* Call = expr->left()->AsCall()) {
           return ValidateCall(AsmType::Double(), Call);
         }
         AsmType* left_type;
         RECURSE(left_type = ValidateExpression(expr->left()));
+        SetTypeOf(expr->right(), AsmType::Double());
         UNOP_OVERLOAD(Signed, Double);
         UNOP_OVERLOAD(Unsigned, Double);
         UNOP_OVERLOAD(DoubleQ, Double);
         UNOP_OVERLOAD(FloatQ, Double);
         FAIL(expr, "Invalid type for conversion to double.");
       }
 
       if (IsUnaryMinus(expr)) {
         // *VIOLATION* the parser converts -x to x * -1.0.
         AsmType* left_type;
         RECURSE(left_type = ValidateExpression(expr->left()));
+        SetTypeOf(expr->right(), left_type);
         UNOP_OVERLOAD(Int, Intish);
         UNOP_OVERLOAD(DoubleQ, Double);
         UNOP_OVERLOAD(FloatQ, Floatish);
         FAIL(expr, "Invalid type for unary -.");
       }
     // FALTHROUGH
     case Token::DIV:
     case Token::MOD:
       return ValidateMultiplicativeExpression(expr);
     case Token::ADD:
     case Token::SUB: {
       static const uint32_t kInitialIntishCount = 0;
       return ValidateAdditiveExpression(expr, kInitialIntishCount);
     }
     case Token::SAR:
     case Token::SHL:
     case Token::SHR:
       return ValidateShiftExpression(expr);
     case Token::BIT_AND:
       return ValidateBitwiseANDExpression(expr);
     case Token::BIT_XOR:
       if (IsNegate(expr)) {
         auto* left = expr->left();
         auto* left_as_binop = left->AsBinaryOperation();
 
         if (left_as_binop != nullptr && IsNegate(left_as_binop)) {
           // This is the special ~~ operator.
           AsmType* left_type;
           RECURSE(left_type = ValidateExpression(left_as_binop->left()));
+          SetTypeOf(left_as_binop->right(), AsmType::FixNum());
+          SetTypeOf(left_as_binop, AsmType::Signed());
+          SetTypeOf(expr->right(), AsmType::FixNum());
           UNOP_OVERLOAD(Double, Signed);
           UNOP_OVERLOAD(FloatQ, Signed);
           FAIL(left_as_binop, "Invalid type for conversion to signed.");
         }
 
         AsmType* left_type;
         RECURSE(left_type = ValidateExpression(left));
         UNOP_OVERLOAD(Intish, Signed);
         FAIL(left, "Invalid type for ~.");
       }
 
       return ValidateBitwiseXORExpression(expr);
     case Token::BIT_OR:
       return ValidateBitwiseORExpression(expr);
   }
 #undef UNOP_OVERLOAD
   UNREACHABLE();
 }
 
 // 6.8.1 Expression
 AsmType* AsmTyper::ValidateCommaExpression(BinaryOperation* comma) {
   // The AST looks like:
   // (expr COMMA (expr COMMA (expr COMMA (... ))))
 
   auto* left = comma->left();
-  auto* left_as_binop = left->AsBinaryOperation();
-  if (left_as_binop && left_as_binop->op() == Token::COMMA) {
-    ValidateCommaExpression(left_as_binop);
-  } else if (auto* left_as_call = left->AsCall()) {
-    ValidateCall(AsmType::Void(), left_as_call);
+  if (auto* left_as_call = left->AsCall()) {
+    RECURSE(ValidateCall(AsmType::Void(), left_as_call));
   } else {
-    ValidateExpression(left);
+    RECURSE(ValidateExpression(left));
   }
 
   auto* right = comma->right();
-  auto* right_as_binop = right->AsBinaryOperation();
-  if (right_as_binop && right_as_binop->op() == Token::COMMA) {
-    return ValidateCommaExpression(right_as_binop);
+  AsmType* right_type = nullptr;
+  if (auto* right_as_call = right->AsCall()) {
+    RECURSE(right_type = ValidateCall(AsmType::Void(), right_as_call));
   } else {
-    return ValidateExpression(right);
+    RECURSE(right_type = ValidateExpression(right));
   }
 
-  UNREACHABLE();
+  return right_type;
 }
 
 // 6.8.2 NumericLiteral
 AsmType* AsmTyper::ValidateNumericLiteral(Literal* literal) {
   // *VIOLATION* asm.js does not allow the use of undefined, but our parser
   // inserts them, so we have to handle them.
   if (literal->IsUndefinedLiteral()) {
     return AsmType::Void();
   }
 
   if (literal->raw_value()->ContainsDot()) {
     return AsmType::Double();
   }
 
   uint32_t value;
   if (!literal->value()->ToUint32(&value)) {
     int32_t value;
     if (!literal->value()->ToInt32(&value)) {
       FAIL(literal, "Integer literal is out of range.");
     }
     // *VIOLATION* Not really a violation, but rather a different in the
     // validation. The spec handles -NumericLiteral in ValidateUnaryExpression,
     // but V8's AST represents the negative literals as Literals.
     return AsmType::Signed();
   }
 
-  static const uint32_t LargestFixNum = std::numeric_limits<int32_t>::max();
   if (value <= LargestFixNum) {
     return AsmType::FixNum();
   }
 
   return AsmType::Unsigned();
 }
 
 // 6.8.3 Identifier
 AsmType* AsmTyper::ValidateIdentifier(VariableProxy* proxy) {
   auto* proxy_info = Lookup(proxy->var());
@@ skipping 66 matching lines @@
 
     return value_type;
   }
 
   if (auto* target_as_property = assignment->target()->AsProperty()) {
     AsmType* allowed_store_types;
     RECURSE(allowed_store_types =
                 ValidateHeapAccess(target_as_property, StoreToHeap));
 
     // TODO(jpp): Change FloatishDoubleQ and FloatQDoubleQ so that they are base
-    // classes for Floatish, DoubleQ, and FloatQ, and then invert this if so
-    // that it reads more naturally as
-    //
-    // if (!value_type->IsA(allowed_store_types))
-    if (allowed_store_types == AsmType::FloatishDoubleQ() ||
-        allowed_store_types == AsmType::FloatQDoubleQ()) {
-      if (!allowed_store_types->IsA(value_type)) {
+    // classes for Floatish, DoubleQ, and FloatQ.
+    if (allowed_store_types == AsmType::FloatishDoubleQ()) {
+      if (!value_type->IsA(AsmType::Floatish()) &&
+          !value_type->IsA(AsmType::DoubleQ())) {
+        FAIL(assignment, "Type mismatch in heap assignment.");
+      }
+    } else if (allowed_store_types == AsmType::FloatQDoubleQ()) {
+      if (!value_type->IsA(AsmType::FloatQ()) &&
+          !value_type->IsA(AsmType::DoubleQ())) {
         FAIL(assignment, "Type mismatch in heap assignment.");
       }
     } else {
       if (!value_type->IsA(allowed_store_types)) {
         FAIL(assignment, "Type mismatch in heap assignment.");
       }
     }
 
     return value_type;
   }
@@ skipping 164 matching lines @@
   auto* left = binop->left();
   auto* left_as_binop = left->AsBinaryOperation();
   AsmType* left_type;
 
   // TODO(jpp): maybe use an iterative approach instead of the recursion to
   // ValidateAdditiveExpression.
   if (left_as_binop != nullptr && (left_as_binop->op() == Token::ADD ||
                                    left_as_binop->op() == Token::SUB)) {
     RECURSE(left_type =
                 ValidateAdditiveExpression(left_as_binop, intish_count + 1));
+    SetTypeOf(left_as_binop, left_type);
   } else {
     RECURSE(left_type = ValidateExpression(left));
   }
 
   auto* right = binop->right();
   auto* right_as_binop = right->AsBinaryOperation();
   AsmType* right_type;
 
   if (right_as_binop != nullptr && (right_as_binop->op() == Token::ADD ||
                                     right_as_binop->op() == Token::SUB)) {
     RECURSE(right_type =
                 ValidateAdditiveExpression(right_as_binop, intish_count + 1));
+    SetTypeOf(right_as_binop, right_type);
   } else {
     RECURSE(right_type = ValidateExpression(right));
   }
 
   if (left_type->IsA(AsmType::FloatQ()) && right_type->IsA(AsmType::FloatQ())) {
     return AsmType::Floatish();
   }
 
   if (left_type->IsA(AsmType::Int()) && right_type->IsA(AsmType::Int())) {
     if (intish_count == 0) {
@@ skipping 274 matching lines @@
   if (as_literal->raw_value()->ContainsDot()) {
     return false;
   }
 
   if (!as_literal->value()->ToUint32(value)) {
     return false;
   }
 
   return base::bits::IsPowerOfTwo32(1 + *value);
 }
-
-// TODO(jpp): Add a AsmType::ValidateCall is poorly designed. It can only handle
-// function declarations, not invocations. CheckInvocationOf temporarily works
-// around this limitation by converting each actual in actuals to a parameter
-// type before invoking prototype->ValidateCall. This is the wrong behavior for
-// FFIs (we need to pass Signed integers to FFIs, not Ints), so that case is
-// handled separately.
-bool CheckInvocationOf(AsmCallableType* prototype, AsmType* return_type,
-                       ZoneVector<AsmType*>* actuals) {
-  if (auto* ffi = prototype->AsFFIType()) {
-    return ffi->ValidateCall(return_type, *actuals) != AsmType::None();
-  }
-
-  for (size_t ii = 0; ii < actuals->size(); ++ii) {
-    (*actuals)[ii] = (*actuals)[ii]->ToParameterType();
-  }
-  return prototype->ValidateCall(return_type, *actuals) != AsmType::None();
-}
-
 }  // namespace
 
 AsmType* AsmTyper::ValidateCall(AsmType* return_type, Call* call) {
   AsmType* float_coercion_type;
   RECURSE(float_coercion_type = ValidateFloatCoercion(call));
   if (float_coercion_type == AsmType::Float()) {
-    return AsmType::Float();
+    SetTypeOf(call, AsmType::Float());
+    return return_type;
   }
 
   // TODO(jpp): we should be able to reuse the args vector's storage space.
   ZoneVector<AsmType*> args(zone_);
   args.reserve(call->arguments()->length());
 
   for (auto* arg : *call->arguments()) {
     AsmType* arg_type;
     RECURSE(arg_type = ValidateExpression(arg));
     args.emplace_back(arg_type);
@@ skipping 18 matching lines @@
       fun_info->set_mutability(VariableInfo::kImmutableGlobal);
       AddForwardReference(call_var_proxy, fun_info);
       if (!ValidAsmIdentifier(call_var_proxy->name())) {
         FAIL(call_var_proxy,
              "Invalid asm.js identifier in (forward) function name.");
       }
       if (!AddGlobal(call_var_proxy->var(), fun_info)) {
         DCHECK(false);
         FAIL(call, "Redeclared global identifier.");
       }
+      SetTypeOf(call_var_proxy, reinterpret_cast<AsmType*>(call_type));
+      SetTypeOf(call, return_type);
       return return_type;
     }
 
     auto* callee_type = call_var_info->type()->AsCallableType();
     if (callee_type == nullptr) {
       FAIL(call, "Calling something that's not a function.");
     }
 
     if (callee_type->AsFFIType() != nullptr &&
         return_type == AsmType::Float()) {
       FAIL(call, "Foreign functions can't return float.");
     }
 
-    if (!CheckInvocationOf(callee_type, return_type, &args)) {
+    if (!callee_type->CanBeInvokedWith(return_type, args)) {
       FAIL(call, "Function invocation does not match function type.");
     }
 
+    SetTypeOf(call_var_proxy, call_var_info->type());
+    SetTypeOf(call, return_type);
     return return_type;
   }
 
   // identifier[expr & n](Expression...)
   if (auto* call_property = call_expr->AsProperty()) {
     auto* index = call_property->key()->AsBinaryOperation();
     if (index == nullptr || index->op() != Token::BIT_AND) {
       FAIL(call_property->key(),
            "Indirect call index must be in the expr & mask form.");
     }
@@ skipping 36 matching lines @@
       fun_info->set_mutability(VariableInfo::kImmutableGlobal);
       AddForwardReference(name_var, fun_info);
       if (!ValidAsmIdentifier(name_var->name())) {
         FAIL(name_var,
              "Invalid asm.js identifier in (forward) function table name.");
       }
       if (!AddGlobal(name_var->var(), fun_info)) {
         DCHECK(false);
         FAIL(call, "Redeclared global identifier.");
       }
+      SetTypeOf(call_property, reinterpret_cast<AsmType*>(call_type));
+      SetTypeOf(call, return_type);
       return return_type;
     }
 
     auto* previous_type = name_info->type()->AsFunctionTableType();
     if (previous_type == nullptr) {
       FAIL(call, "Identifier does not name a function table.");
     }
 
     if (table_length != previous_type->length()) {
       FAIL(call, "Function table size does not match expected size.");
     }
 
     auto* previous_type_signature =
         previous_type->signature()->AsFunctionType();
     DCHECK(previous_type_signature != nullptr);
-    if (!CheckInvocationOf(previous_type_signature, return_type, &args)) {
+    if (!previous_type_signature->CanBeInvokedWith(return_type, args)) {
+      // TODO(jpp): better error messages.
       FAIL(call,
            "Function pointer table signature does not match previous "
            "signature.");
     }
 
+    SetTypeOf(call_property, previous_type->signature());
+    SetTypeOf(call, return_type);
     return return_type;
   }
 
   FAIL(call, "Invalid call.");
 }
 
 // 6.10 ValidateHeapAccess
 namespace {
 bool ExtractHeapAccessShift(Expression* expr, uint32_t* value) {
   auto* as_literal = expr->AsLiteral();
@@ skipping 18 matching lines @@
 
   auto* obj_info = Lookup(obj->var());
   if (obj_info == nullptr) {
     FAIL(heap, "Undeclared identifier in heap access.");
   }
 
   auto* obj_type = obj_info->type();
   if (!obj_type->IsA(AsmType::Heap())) {
     FAIL(heap, "Identifier does not represent a heap view.");
   }
+  SetTypeOf(obj, obj_type);
 
   if (auto* key_as_literal = heap->key()->AsLiteral()) {
     if (key_as_literal->raw_value()->ContainsDot()) {
       FAIL(key_as_literal, "Heap access index must be intish.");
     }
 
     uint32_t _;
     if (!key_as_literal->value()->ToUint32(&_)) {
       FAIL(key_as_literal,
            "Heap access index must be a 32-bit unsigned integer.");
@@ skipping 71 matching lines @@
   if (auto* arg_as_call = arg->AsCall()) {
     RECURSE(ValidateCall(AsmType::Float(), arg_as_call));
     return AsmType::Float();
   }
 
   // 2. fround is used for converting to float.
   AsmType* arg_type;
   RECURSE(arg_type = ValidateExpression(arg));
   if (arg_type->IsA(AsmType::Floatish()) || arg_type->IsA(AsmType::DoubleQ()) ||
       arg_type->IsA(AsmType::Signed()) || arg_type->IsA(AsmType::Unsigned())) {
+    SetTypeOf(call->expression(), fround_type_);
     return AsmType::Float();
   }
 
   FAIL(call, "Invalid argument type to fround.");
 }
 
 // 5.1 ParameterTypeAnnotations
 AsmType* AsmTyper::ParameterTypeAnnotations(Variable* parameter,
                                             Expression* annotation) {
   if (auto* binop = annotation->AsBinaryOperation()) {
     // Must be:
     //   * x|0
     //   * x*1 (*VIOLATION* i.e.,, +x)
     auto* left = binop->left()->AsVariableProxy();
     if (left == nullptr) {
       FAIL(
           binop->left(),
           "Invalid parameter type annotation - should annotate an identifier.");
     }
     if (left->var() != parameter) {
       FAIL(binop->left(),
            "Invalid parameter type annotation - should annotate a parameter.");
     }
     if (IsDoubleAnnotation(binop)) {
+      SetTypeOf(left, AsmType::Double());
       return AsmType::Double();
     }
     if (IsIntAnnotation(binop)) {
+      SetTypeOf(left, AsmType::Int());
       return AsmType::Int();
     }
     FAIL(binop, "Invalid parameter type annotation.");
   }
 
   auto* call = annotation->AsCall();
   if (call == nullptr) {
     FAIL(
         annotation,
         "Invalid float parameter type annotation - must be fround(parameter).");
@@ skipping 10 matching lines @@
          "Invalid float parameter type annotation - argument to fround is not "
          "an identifier.");
   }
 
   if (src_expr->var() != parameter) {
     FAIL(annotation,
          "Invalid float parameter type annotation - argument to fround is not "
          "a parameter.");
   }
 
+  SetTypeOf(src_expr, AsmType::Float());
   return AsmType::Float();
 }
 
 // 5.2 ReturnTypeAnnotations
 AsmType* AsmTyper::ReturnTypeAnnotations(ReturnStatement* statement) {
   if (statement == nullptr) {
     return AsmType::Void();
   }
 
   auto* ret_expr = statement->expression();
@@ skipping 37 matching lines @@
   }
 
   FAIL(statement, "Invalid return type expression.");
 }
 
 // 5.4 VariableTypeAnnotations
 // Also used for 5.5 GlobalVariableTypeAnnotations
 AsmType* AsmTyper::VariableTypeAnnotations(Expression* initializer) {
   if (auto* literal = initializer->AsLiteral()) {
     if (literal->raw_value()->ContainsDot()) {
+      SetTypeOf(initializer, AsmType::Double());
       return AsmType::Double();
     }
     int32_t i32;
     uint32_t u32;
-    if (literal->value()->ToInt32(&i32) || literal->value()->ToUint32(&u32)) {
-      return AsmType::Int();
+    if (literal->value()->ToUint32(&u32)) {
+      if (u32 > LargestFixNum) {
+        SetTypeOf(initializer, AsmType::Unsigned());
+      } else {
+        SetTypeOf(initializer, AsmType::FixNum());
+      }
+    } else if (literal->value()->ToInt32(&i32)) {
+      SetTypeOf(initializer, AsmType::Signed());
+    } else {
+      FAIL(initializer, "Invalid type annotation - forbidden literal.");
     }
-    FAIL(initializer, "Invalid type annotation - forbidden literal.");
+    return AsmType::Int();
   }
 
   auto* call = initializer->AsCall();
-  DCHECK(call != nullptr);
   if (call == nullptr) {
     FAIL(initializer,
          "Invalid variable initialization - it should be a literal, or "
          "fround(literal).");
   }
 
   if (!IsCallToFround(call)) {
     FAIL(initializer,
          "Invalid float coercion - expected call fround(literal).");
   }
@@ skipping 66 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8