Hooking up asm-wasm conversion.

src/asmjs/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/typing-asm.h"
+#include "src/asmjs/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/codegen.h"
 #include "src/type-cache.h"
 
@@ skipping 20 matching lines @@
   } 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),
+      fixed_signature_(false),
       property_info_(nullptr),
       intish_(0),
       stdlib_types_(zone),
       stdlib_heap_types_(zone),
       stdlib_math_types_(zone),
 #define V(NAME, Name, name, lane_count, lane_type) \
   stdlib_simd_##name##_types_(zone),
       SIMD128_TYPES(V)
 #undef V
           global_variable_type_(base::HashMap::PointersMatch,
                                 ZoneHashMap::kDefaultHashMapCapacity,
                                 ZoneAllocationPolicy(zone)),
       local_variable_type_(base::HashMap::PointersMatch,
                            ZoneHashMap::kDefaultHashMapCapacity,
                            ZoneAllocationPolicy(zone)),
       in_function_(false),
       building_function_tables_(false),
       visiting_exports_(false),
       cache_(TypeCache::Get()),
       bounds_(zone) {
   InitializeAstVisitor(isolate);
   InitializeStdlib();
 }
 
-
 bool AsmTyper::Validate() {
   VisitAsmModule(root_);
   return valid_ && !HasStackOverflow();
 }
 
-
 void AsmTyper::VisitAsmModule(FunctionLiteral* fun) {
   Scope* scope = fun->scope();
   if (!scope->is_function_scope()) FAIL(fun, "not at function scope");
 
   ExpressionStatement* use_asm = fun->body()->first()->AsExpressionStatement();
   if (use_asm == nullptr) FAIL(fun, "missing \"use asm\"");
   Literal* use_asm_literal = use_asm->expression()->AsLiteral();
   if (use_asm_literal == nullptr) FAIL(fun, "missing \"use asm\"");
   if (!use_asm_literal->raw_value()->AsString()->IsOneByteEqualTo("use asm"))
     FAIL(fun, "missing \"use asm\"");
 
+  // TODO(bradnelson): Generalize this.
+  if (fixed_signature_ && scope->num_parameters() != 3) {
+    FAIL(fun,
+         "only asm modules with (stdlib, foreign, heap) "
+         "parameters currently supported");
+  }
+
   // Module parameters.
   for (int i = 0; i < scope->num_parameters(); ++i) {
     Variable* param = scope->parameter(i);
     DCHECK(GetType(param) == nullptr);
     SetType(param, Type::None());
   }
 
   ZoneList<Declaration*>* decls = scope->declarations();
 
   // Set all globals to type Any.
@@ skipping 38 matching lines @@
   // Validate exports.
   visiting_exports_ = true;
   ReturnStatement* stmt = fun->body()->last()->AsReturnStatement();
   if (stmt == nullptr) {
     FAIL(fun->body()->last(), "last statement in module is not a return");
   }
   RECURSE(VisitWithExpectation(stmt->expression(), Type::Object(),
                                "expected object export"));
 }
 
-
 void AsmTyper::VisitVariableDeclaration(VariableDeclaration* decl) {
   Variable* var = decl->proxy()->var();
   if (var->location() != VariableLocation::PARAMETER) {
     if (GetType(var) == nullptr) {
       SetType(var, Type::Any());
     } else {
       DCHECK(!GetType(var)->IsFunction());
     }
   }
   DCHECK(GetType(var) != nullptr);
   intish_ = 0;
 }
 
-
 void AsmTyper::VisitFunctionDeclaration(FunctionDeclaration* decl) {
   if (in_function_) {
     FAIL(decl, "function declared inside another");
   }
   // Set function type so global references to functions have some type
   // (so they can give a more useful error).
   Variable* var = decl->proxy()->var();
   if (GetVariableInfo(var)) {
     // Detect previously-seen functions.
     FAIL(decl->fun(), "function repeated in module");
   }
   SetType(var, Type::Function());
 }
 
-
 void AsmTyper::VisitFunctionAnnotation(FunctionLiteral* fun) {
   // Extract result type.
   ZoneList<Statement*>* body = fun->body();
   Type* result_type = Type::Undefined();
   if (body->length() > 0) {
     ReturnStatement* stmt = body->last()->AsReturnStatement();
     if (stmt != nullptr) {
       Literal* literal = stmt->expression()->AsLiteral();
       Type* old_expected = expected_type_;
       expected_type_ = Type::Any();
@@ skipping 30 matching lines @@
     }
     SetType(var, computed_type_);
     type->AsFunction()->InitParameter(i, computed_type_);
     good = true;
   }
   if (!good) FAIL(fun, "missing parameter type annotations");
 
   SetResult(fun, type);
 }
 
-
 void AsmTyper::VisitExpressionAnnotation(Expression* expr, Variable* var,
                                          bool is_return) {
   // Normal +x or x|0 annotations.
   BinaryOperation* bin = expr->AsBinaryOperation();
   if (bin != nullptr) {
     if (var != nullptr) {
       VariableProxy* proxy = bin->left()->AsVariableProxy();
       if (proxy == nullptr) {
         FAIL(bin->left(), "expected variable for type annotation");
       }
@@ skipping 59 matching lines @@
         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) {
     Statement* stmt = stmts->at(i);
     RECURSE(Visit(stmt));
   }
 }
 
-
 void AsmTyper::VisitBlock(Block* stmt) {
   RECURSE(VisitStatements(stmt->statements()));
 }
 
-
 void AsmTyper::VisitExpressionStatement(ExpressionStatement* stmt) {
   RECURSE(VisitWithExpectation(stmt->expression(), Type::Any(),
                                "expression statement expected to be any"));
 }
 
-
 void AsmTyper::VisitEmptyStatement(EmptyStatement* stmt) {}
 
-
 void AsmTyper::VisitSloppyBlockFunctionStatement(
     SloppyBlockFunctionStatement* stmt) {
   Visit(stmt->statement());
 }
 
-
 void AsmTyper::VisitEmptyParentheses(EmptyParentheses* expr) { UNREACHABLE(); }
 
-
 void AsmTyper::VisitIfStatement(IfStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "if statement inside module body");
   }
   RECURSE(VisitWithExpectation(stmt->condition(), cache_.kAsmInt,
                                "if condition expected to be integer"));
   if (intish_ != 0) {
     FAIL(stmt, "if condition expected to be signed or unsigned");
   }
   RECURSE(Visit(stmt->then_statement()));
   RECURSE(Visit(stmt->else_statement()));
 }
 
-
 void AsmTyper::VisitContinueStatement(ContinueStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "continue statement inside module body");
   }
 }
 
-
 void AsmTyper::VisitBreakStatement(BreakStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "continue statement inside module body");
   }
 }
 
-
 void AsmTyper::VisitReturnStatement(ReturnStatement* stmt) {
   // Handle module return statement in VisitAsmModule.
   if (!in_function_) {
     return;
   }
   Literal* literal = stmt->expression()->AsLiteral();
   if (literal) {
     VisitLiteral(literal, true);
   } else {
     RECURSE(
         VisitWithExpectation(stmt->expression(), Type::Any(),
                              "return expression expected to have return type"));
   }
   if (!computed_type_->Is(return_type_) || !return_type_->Is(computed_type_)) {
     FAIL(stmt->expression(), "return type does not match function signature");
   }
 }
 
-
 void AsmTyper::VisitWithStatement(WithStatement* stmt) {
   FAIL(stmt, "bad with statement");
 }
 
-
 void AsmTyper::VisitSwitchStatement(SwitchStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "switch statement inside module body");
   }
   RECURSE(VisitWithExpectation(stmt->tag(), cache_.kAsmSigned,
                                "switch expression non-integer"));
   ZoneList<CaseClause*>* clauses = stmt->cases();
   ZoneSet<int32_t> cases(zone());
   for (int i = 0; i < clauses->length(); ++i) {
     CaseClause* clause = clauses->at(i);
@@ skipping 20 matching lines @@
   }
   if (cases.size() > 0) {
     int64_t min_case = *cases.begin();
     int64_t max_case = *cases.rbegin();
     if (max_case - min_case > std::numeric_limits<int32_t>::max()) {
       FAIL(stmt, "case range too large");
     }
   }
 }
 
-
 void AsmTyper::VisitCaseClause(CaseClause* clause) { UNREACHABLE(); }
 
-
 void AsmTyper::VisitDoWhileStatement(DoWhileStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "do statement inside module body");
   }
   RECURSE(Visit(stmt->body()));
   RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmInt,
                                "do condition expected to be integer"));
   if (intish_ != 0) {
     FAIL(stmt, "do condition expected to be signed or unsigned");
   }
 }
 
-
 void AsmTyper::VisitWhileStatement(WhileStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "while statement inside module body");
   }
   RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmInt,
                                "while condition expected to be integer"));
   if (intish_ != 0) {
     FAIL(stmt, "while condition expected to be signed or unsigned");
   }
   RECURSE(Visit(stmt->body()));
 }
 
-
 void AsmTyper::VisitForStatement(ForStatement* stmt) {
   if (!in_function_) {
     FAIL(stmt, "for statement inside module body");
   }
   if (stmt->init() != nullptr) {
     RECURSE(Visit(stmt->init()));
   }
   if (stmt->cond() != nullptr) {
     RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmInt,
                                  "for condition expected to be integer"));
   }
   if (intish_ != 0) {
     FAIL(stmt, "for condition expected to be signed or unsigned");
   }
   if (stmt->next() != nullptr) {
     RECURSE(Visit(stmt->next()));
   }
   RECURSE(Visit(stmt->body()));
 }
 
-
 void AsmTyper::VisitForInStatement(ForInStatement* stmt) {
   FAIL(stmt, "for-in statement encountered");
 }
 
-
 void AsmTyper::VisitForOfStatement(ForOfStatement* stmt) {
   FAIL(stmt, "for-of statement encountered");
 }
 
-
 void AsmTyper::VisitTryCatchStatement(TryCatchStatement* stmt) {
   FAIL(stmt, "try statement encountered");
 }
 
-
 void AsmTyper::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   FAIL(stmt, "try statement encountered");
 }
 
-
 void AsmTyper::VisitDebuggerStatement(DebuggerStatement* stmt) {
   FAIL(stmt, "debugger statement encountered");
 }
 
-
 void AsmTyper::VisitFunctionLiteral(FunctionLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "invalid nested function");
   }
   Scope* scope = expr->scope();
   DCHECK(scope->is_function_scope());
 
   if (!bounds_.get(expr).upper->IsFunction()) {
     FAIL(expr, "invalid function literal");
   }
 
   Type* type = bounds_.get(expr).upper;
   Type* save_return_type = return_type_;
   return_type_ = type->AsFunction()->Result();
   in_function_ = true;
   local_variable_type_.Clear();
   RECURSE(VisitDeclarations(scope->declarations()));
   RECURSE(VisitStatements(expr->body()));
   in_function_ = false;
   return_type_ = save_return_type;
   RECURSE(IntersectResult(expr, type));
 }
 
-
 void AsmTyper::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   FAIL(expr, "function info literal encountered");
 }
 
-
 void AsmTyper::VisitDoExpression(DoExpression* expr) {
   FAIL(expr, "do-expression encountered");
 }
 
-
 void AsmTyper::VisitConditional(Conditional* expr) {
   if (!in_function_) {
     FAIL(expr, "ternary operator inside module body");
   }
   RECURSE(VisitWithExpectation(expr->condition(), Type::Number(),
                                "condition expected to be integer"));
   if (!computed_type_->Is(cache_.kAsmInt)) {
     FAIL(expr->condition(), "condition must be of type int");
   }
 
@@ skipping 15 matching lines @@
         (then_type->Is(cache_.kAsmDouble) &&
          else_type->Is(cache_.kAsmDouble)))) {
     FAIL(expr,
          "then and else expressions in ? must have the same type "
          "and be int, float, or double");
   }
 
   RECURSE(IntersectResult(expr, then_type));
 }
 
-
 void AsmTyper::VisitVariableProxy(VariableProxy* expr) {
   Variable* var = expr->var();
   VariableInfo* info = GetVariableInfo(var);
   if (!in_function_ && !building_function_tables_ && !visiting_exports_) {
     if (var->location() != VariableLocation::PARAMETER || var->index() >= 3) {
       FAIL(expr, "illegal variable reference in module body");
     }
   }
   if (info == nullptr || info->type == nullptr) {
     if (var->mode() == TEMPORARY) {
@@ skipping 34 matching lines @@
     }
   } else if (!is_return && value->IsString()) {
     RECURSE(IntersectResult(expr, Type::String()));
   } else if (value->IsUndefined(isolate_)) {
     RECURSE(IntersectResult(expr, Type::Undefined()));
   } else {
     FAIL(expr, "illegal literal");
   }
 }
 
-
 void AsmTyper::VisitLiteral(Literal* expr) { VisitLiteral(expr, false); }
 
-
 void AsmTyper::VisitRegExpLiteral(RegExpLiteral* expr) {
   FAIL(expr, "regular expression encountered");
 }
 
-
 void AsmTyper::VisitObjectLiteral(ObjectLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "object literal in function");
   }
   // Allowed for asm module's export declaration.
   ZoneList<ObjectLiteralProperty*>* props = expr->properties();
   for (int i = 0; i < props->length(); ++i) {
     ObjectLiteralProperty* prop = props->at(i);
     RECURSE(VisitWithExpectation(prop->value(), Type::Any(),
                                  "object property expected to be a function"));
     if (!computed_type_->IsFunction()) {
       FAIL(prop->value(), "non-function in function table");
     }
   }
   RECURSE(IntersectResult(expr, Type::Object()));
 }
 
-
 void AsmTyper::VisitArrayLiteral(ArrayLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "array literal inside a function");
   }
   // Allowed for function tables.
   ZoneList<Expression*>* values = expr->values();
   Type* elem_type = Type::None();
   for (int i = 0; i < values->length(); ++i) {
     Expression* value = values->at(i);
     RECURSE(VisitWithExpectation(value, Type::Any(), "UNREACHABLE"));
     if (!computed_type_->IsFunction()) {
       FAIL(value, "array component expected to be a function");
     }
     elem_type = Type::Union(elem_type, computed_type_, zone());
   }
   array_size_ = values->length();
   RECURSE(IntersectResult(expr, Type::Array(elem_type, zone())));
 }
 
-
 void AsmTyper::VisitAssignment(Assignment* expr) {
   // Handle function tables and everything else in different passes.
   if (!in_function_) {
     if (expr->value()->IsArrayLiteral()) {
       if (!building_function_tables_) {
         return;
       }
     } else {
       if (building_function_tables_) {
         return;
@@ skipping 45 matching lines @@
       FAIL(property->obj(), "array expected");
     }
     if (value_intish != 0 && computed_type_->Is(cache_.kFloat64Array)) {
       FAIL(expr, "floatish assignment to double array");
     }
     VisitHeapAccess(property, true, target_type);
   }
   RECURSE(IntersectResult(expr, target_type));
 }
 
-
 void AsmTyper::VisitYield(Yield* expr) {
   FAIL(expr, "yield expression encountered");
 }
 
-
 void AsmTyper::VisitThrow(Throw* expr) {
   FAIL(expr, "throw statement encountered");
 }
 
-
 int AsmTyper::ElementShiftSize(Type* type) {
   if (type->Is(cache_.kAsmSize8)) return 0;
   if (type->Is(cache_.kAsmSize16)) return 1;
   if (type->Is(cache_.kAsmSize32)) return 2;
   if (type->Is(cache_.kAsmSize64)) return 3;
   return -1;
 }
 
-
 Type* AsmTyper::StorageType(Type* type) {
   if (type->Is(cache_.kAsmInt)) {
     return cache_.kAsmInt;
   } else {
     return type;
   }
 }
 
-
 void AsmTyper::VisitHeapAccess(Property* expr, bool assigning,
                                Type* assignment_type) {
   ArrayType* array_type = computed_type_->AsArray();
   //  size_t size = array_size_;
   Type* type = array_type->Element();
   if (type->IsFunction()) {
     if (assigning) {
       FAIL(expr, "assigning to function table is illegal");
     }
     // TODO(bradnelson): Fix the parser and then un-comment this part
@@ skipping 73 matching lines @@
       if (!assignment_type->Is(result_type)) {
         FAIL(expr, "illegal type in assignment");
       }
     } else {
       RECURSE(IntersectResult(expr, expected_type_));
       RECURSE(IntersectResult(expr, result_type));
     }
   }
 }
 
-
 bool AsmTyper::IsStdlibObject(Expression* expr) {
   VariableProxy* proxy = expr->AsVariableProxy();
   if (proxy == nullptr) {
     return false;
   }
   Variable* var = proxy->var();
   VariableInfo* info = GetVariableInfo(var);
   if (info) {
     if (info->standard_member == kStdlib) return true;
   }
   if (var->location() != VariableLocation::PARAMETER || var->index() != 0) {
     return false;
   }
   info = MakeVariableInfo(var);
   info->type = Type::Object();
   info->standard_member = kStdlib;
   return true;
 }
 
-
 Expression* AsmTyper::GetReceiverOfPropertyAccess(Expression* expr,
                                                   const char* name) {
   Property* property = expr->AsProperty();
   if (property == nullptr) {
     return nullptr;
   }
   Literal* key = property->key()->AsLiteral();
   if (key == nullptr || !key->IsPropertyName() ||
       !key->AsPropertyName()->IsUtf8EqualTo(CStrVector(name))) {
     return nullptr;
   }
   return property->obj();
 }
 
-
 bool AsmTyper::IsMathObject(Expression* expr) {
   Expression* obj = GetReceiverOfPropertyAccess(expr, "Math");
   return obj && IsStdlibObject(obj);
 }
 
-
 bool AsmTyper::IsSIMDObject(Expression* expr) {
   Expression* obj = GetReceiverOfPropertyAccess(expr, "SIMD");
   return obj && IsStdlibObject(obj);
 }
 
-
 bool AsmTyper::IsSIMDTypeObject(Expression* expr, const char* name) {
   Expression* obj = GetReceiverOfPropertyAccess(expr, name);
   return obj && IsSIMDObject(obj);
 }
 
-
 void AsmTyper::VisitProperty(Property* expr) {
   if (IsMathObject(expr->obj())) {
     VisitLibraryAccess(&stdlib_math_types_, expr);
     return;
   }
 #define V(NAME, Name, name, lane_count, lane_type)               \
   if (IsSIMDTypeObject(expr->obj(), #Name)) {                    \
     VisitLibraryAccess(&stdlib_simd_##name##_types_, expr);      \
     return;                                                      \
   }                                                              \
@@ skipping 143 matching lines @@
       }
       RECURSE(CheckPolymorphicStdlibArguments(standard_member, args));
       intish_ = 0;
       RECURSE(IntersectResult(expr, result_type));
     }
   } else {
     FAIL(expr, "invalid callee");
   }
 }
 
-
 void AsmTyper::VisitCallNew(CallNew* expr) {
   if (in_function_) {
     FAIL(expr, "new not allowed in module function");
   }
   RECURSE(VisitWithExpectation(expr->expression(), Type::Any(),
                                "expected stdlib function"));
   if (computed_type_->IsFunction()) {
     FunctionType* fun_type = computed_type_->AsFunction();
     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),
           "constructor argument expected to match callee parameter"));
     }
     RECURSE(IntersectResult(expr, fun_type->Result()));
     return;
   }
 
   FAIL(expr, "ill-typed new operator");
 }
 
-
 void AsmTyper::VisitCallRuntime(CallRuntime* expr) {
   FAIL(expr, "runtime call not allowed");
 }
 
-
 void AsmTyper::VisitUnaryOperation(UnaryOperation* expr) {
   if (!in_function_) {
     FAIL(expr, "unary operator inside module body");
   }
   switch (expr->op()) {
     case Token::NOT:  // Used to encode != and !==
       RECURSE(VisitWithExpectation(expr->expression(), cache_.kAsmInt,
                                    "operand expected to be integer"));
       RECURSE(IntersectResult(expr, cache_.kAsmSigned));
       return;
     case Token::DELETE:
       FAIL(expr, "delete operator encountered");
     case Token::VOID:
       FAIL(expr, "void operator encountered");
     case Token::TYPEOF:
       FAIL(expr, "typeof operator encountered");
     default:
       UNREACHABLE();
   }
 }
 
-
 void AsmTyper::VisitCountOperation(CountOperation* expr) {
   FAIL(expr, "increment or decrement operator encountered");
 }
 
-
 void AsmTyper::VisitIntegerBitwiseOperator(BinaryOperation* expr,
                                            Type* left_expected,
                                            Type* right_expected,
                                            Type* result_type, bool conversion) {
   RECURSE(VisitWithExpectation(expr->left(), Type::Number(),
                                "left bitwise operand expected to be a number"));
   int32_t left_intish = intish_;
   Type* left_type = computed_type_;
   if (!left_type->Is(left_expected)) {
     FAIL(expr->left(), "left bitwise operand expected to be an integer");
@@ skipping 23 matching lines @@
     right_type = left_type;
   }
   if (!conversion) {
     if (!left_type->Is(cache_.kAsmIntQ) || !right_type->Is(cache_.kAsmIntQ)) {
       FAIL(expr, "ill-typed bitwise operation");
     }
   }
   RECURSE(IntersectResult(expr, result_type));
 }
 
-
 void AsmTyper::VisitBinaryOperation(BinaryOperation* expr) {
   if (!in_function_) {
     if (expr->op() != Token::BIT_OR && expr->op() != Token::MUL) {
       FAIL(expr, "illegal binary operator inside module body");
     }
     if (!(expr->left()->IsProperty() || expr->left()->IsVariableProxy()) ||
         !expr->right()->IsLiteral()) {
       FAIL(expr, "illegal computation inside module body");
     }
     DCHECK(expr->right()->AsLiteral() != nullptr);
@@ skipping 177 matching lines @@
         return;
       } else {
         FAIL(expr, "ill-typed arithmetic operation");
       }
     }
     default:
       UNREACHABLE();
   }
 }
 
-
 void AsmTyper::VisitCompareOperation(CompareOperation* expr) {
   if (!in_function_) {
     FAIL(expr, "comparison inside module body");
   }
   Token::Value op = expr->op();
   if (op != Token::EQ && op != Token::NE && op != Token::LT &&
       op != Token::LTE && op != Token::GT && op != Token::GTE) {
     FAIL(expr, "illegal comparison operator");
   }
 
@@ skipping 18 matching lines @@
         (left_type->Is(cache_.kAsmDouble) &&
          right_type->Is(cache_.kAsmDouble)))) {
     FAIL(expr,
          "left and right side of comparison must match type "
          "and be signed, unsigned, float, or double");
   }
 
   RECURSE(IntersectResult(expr, cache_.kAsmSigned));
 }
 
-
 void AsmTyper::VisitThisFunction(ThisFunction* expr) {
   FAIL(expr, "this function not allowed");
 }
 
-
 void AsmTyper::VisitDeclarations(ZoneList<Declaration*>* decls) {
   for (int i = 0; i < decls->length(); ++i) {
     Declaration* decl = decls->at(i);
     RECURSE(Visit(decl));
   }
 }
 
-
 void AsmTyper::VisitImportDeclaration(ImportDeclaration* decl) {
   FAIL(decl, "import declaration encountered");
 }
 
-
 void AsmTyper::VisitClassLiteral(ClassLiteral* expr) {
   FAIL(expr, "class literal not allowed");
 }
 
-
 void AsmTyper::VisitSpread(Spread* expr) { FAIL(expr, "spread not allowed"); }
 
-
 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();
   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());
 
@@ skipping 55 matching lines @@
   TYPED_ARRAYS(TYPED_ARRAY)
 #undef TYPED_ARRAY
 
 #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
 }
 
-
 void AsmTyper::VisitLibraryAccess(ObjectTypeMap* map, Property* expr) {
   Literal* key = expr->key()->AsLiteral();
   if (key == nullptr || !key->IsPropertyName())
     FAIL(expr, "invalid key used on stdlib member");
   Handle<String> name = key->AsPropertyName();
   VariableInfo* info = LibType(map, name);
   if (info == nullptr || info->type == nullptr)
     FAIL(expr, "unknown stdlib function");
   SetResult(expr, info->type);
   property_info_ = info;
 }
 
-
 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 nullptr;
   }
   return i->second;
 }
 
-
 void AsmTyper::SetType(Variable* variable, Type* type) {
   VariableInfo* info = MakeVariableInfo(variable);
   info->type = type;
 }
 
-
 Type* AsmTyper::GetType(Variable* variable) {
   VariableInfo* info = GetVariableInfo(variable);
   if (!info) return nullptr;
   return info->type;
 }
 
 AsmTyper::VariableInfo* AsmTyper::GetVariableInfo(Variable* variable) {
   ZoneHashMap* map =
       in_function_ ? &local_variable_type_ : &global_variable_type_;
   ZoneHashMap::Entry* entry =
@@ skipping 15 matching lines @@
 }
 
 void AsmTyper::SetVariableInfo(Variable* variable, const VariableInfo* info) {
   VariableInfo* dest = MakeVariableInfo(variable);
   dest->type = info->type;
   dest->is_check_function = info->is_check_function;
   dest->is_constructor_function = info->is_constructor_function;
   dest->standard_member = info->standard_member;
 }
 
-
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(
     Variable* variable) {
   VariableInfo* info = GetVariableInfo(variable);
   if (!info) return kNone;
   return info->standard_member;
 }
 
-
 void AsmTyper::SetResult(Expression* expr, Type* type) {
   computed_type_ = type;
   bounds_.set(expr, Bounds(computed_type_));
 }
 
-
 void AsmTyper::IntersectResult(Expression* expr, Type* type) {
   computed_type_ = type;
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
   if (Type::Representation(bounded_type, zone())->Is(Type::None())) {
 #ifdef DEBUG
     PrintF("Computed type: ");
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, "type mismatch");
   }
   bounds_.set(expr, Bounds(bounded_type));
 }
 
-
 void AsmTyper::VisitWithExpectation(Expression* expr, Type* expected_type,
                                     const char* msg) {
   Type* save = expected_type_;
   expected_type_ = expected_type;
   RECURSE(Visit(expr));
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
   if (Type::Representation(bounded_type, zone())->Is(Type::None())) {
 #ifdef DEBUG
     PrintF("Computed type: ");
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 
-
 void AsmTyper::VisitRewritableExpression(RewritableExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
-
 }  // namespace internal
 }  // namespace v8