android-7.1.2_r28/s

// 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 <limits>

#include "src/v8.h"

#include "src/ast/ast.h"
#include "src/ast/scopes.h"
#include "src/codegen.h"
#include "src/type-cache.h"

namespace v8 {
namespace internal {

#define FAIL(node, msg)                                        \
  do {                                                         \
    valid_ = false;                                            \
    int line = node->position() == RelocInfo::kNoPosition      \
                   ? -1                                        \
                   : script_->GetLineNumber(node->position()); \
    base::OS::SNPrintF(error_message_, sizeof(error_message_), \
                       "asm: line %d: %s\n", line + 1, msg);   \
    return;                                                    \
  } while (false)


#define RECURSE(call)               \
  do {                              \
    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),
      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\"");

  // 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.
  VariableDeclaration* decl = scope->function();
  if (decl != nullptr) SetType(decl->proxy()->var(), Type::None());
  RECURSE(VisitDeclarations(scope->declarations()));

  // 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 != nullptr) {
      RECURSE(VisitFunctionAnnotation(decl->fun()));
      Variable* var = decl->proxy()->var();
      if (property_info_ != nullptr) {
        SetVariableInfo(var, property_info_);
        property_info_ = nullptr;
      }
      SetType(var, computed_type_);
      DCHECK(GetType(var) != nullptr);
    }
  }

  // Build function tables.
  building_function_tables_ = true;
  RECURSE(VisitStatements(fun->body()));
  building_function_tables_ = false;

  // Validate function bodies.
  for (int i = 0; i < decls->length(); ++i) {
    FunctionDeclaration* decl = decls->at(i)->AsFunctionDeclaration();
    if (decl != nullptr) {
      RECURSE(VisitWithExpectation(decl->fun(), Type::Any(), "UNREACHABLE"));
      if (!computed_type_->IsFunction()) {
        FAIL(decl->fun(), "function literal expected to be a function");
      }
    }
  }

  // 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();
      if (literal) {
        RECURSE(VisitLiteral(literal, true));
      } else {
        RECURSE(VisitExpressionAnnotation(stmt->expression(), nullptr, true));
      }
      expected_type_ = old_expected;
      result_type = computed_type_;
    }
  }
  Type* type =
      Type::Function(result_type, Type::Any(), fun->parameter_count(), zone());

  // 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 == nullptr) break;
    Assignment* expr = stmt->expression()->AsAssignment();
    if (expr == nullptr || expr->is_compound()) break;
    VariableProxy* proxy = expr->target()->AsVariableProxy();
    if (proxy == nullptr) break;
    Variable* var = proxy->var();
    if (var->location() != VariableLocation::PARAMETER || var->index() != i)
      break;
    RECURSE(VisitExpressionAnnotation(expr->value(), var, false));
    if (property_info_ != nullptr) {
      SetVariableInfo(var, property_info_);
      property_info_ = nullptr;
    }
    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");
      }
      if (proxy->var() != var) {
        FAIL(proxy, "annotation source doesn't match destination");
      }
    }
    Literal* right = bin->right()->AsLiteral();
    if (right != nullptr) {
      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;
        case Token::BIT_OR:
          if (!right->raw_value()->ContainsDot() &&
              right->raw_value()->AsNumber() == 0.0) {
            if (is_return) {
              SetResult(expr, cache_.kAsmSigned);
            } else {
              SetResult(expr, cache_.kAsmInt);
            }
            return;
          }
          break;
        default:
          break;
      }
    }
    FAIL(expr, "invalid type annotation on binary op");
  }

  // 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 != nullptr) {
    VariableProxy* proxy = call->expression()->AsVariableProxy();
    if (proxy != nullptr) {
      VariableInfo* info = GetVariableInfo(proxy->var());
      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");
        }
      }
      Type* type = info->type;
      DCHECK(type->IsFunction());
      if (info->is_check_function) {
        DCHECK(type->AsFunction()->Arity() == 1);
      }
      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) {
    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_.kAsmSigned,
                               "if condition expected to be integer"));
  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);
    if (clause->is_default()) {
      if (i != clauses->length() - 1) {
        FAIL(clause, "default case out of order");
      }
    } else {
      Expression* label = clause->label();
      RECURSE(VisitWithExpectation(label, cache_.kAsmSigned,
                                   "case label non-integer"));
      if (!label->IsLiteral()) FAIL(label, "non-literal case label");
      Handle<Object> value = label->AsLiteral()->value();
      int32_t value32;
      if (!value->ToInt32(&value32)) FAIL(label, "illegal case label value");
      if (cases.find(value32) != cases.end()) {
        FAIL(label, "duplicate case value");
      }
      cases.insert(value32);
    }
    // TODO(bradnelson): Detect duplicates.
    ZoneList<Statement*>* stmts = clause->statements();
    RECURSE(VisitStatements(stmts));
  }
  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_.kAsmSigned,
                               "do condition expected to be integer"));
}


void AsmTyper::VisitWhileStatement(WhileStatement* stmt) {
  if (!in_function_) {
    FAIL(stmt, "while statement inside module body");
  }
  RECURSE(VisitWithExpectation(stmt->cond(), cache_.kAsmSigned,
                               "while condition expected to be integer"));
  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_.kAsmSigned,
                                 "for condition expected to be integer"));
  }
  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");
  }

  RECURSE(VisitWithExpectation(
      expr->then_expression(), expected_type_,
      "conditional then branch type mismatch with enclosing expression"));
  Type* then_type = StorageType(computed_type_);
  if (intish_ != 0 || !then_type->Is(cache_.kAsmComparable)) {
    FAIL(expr->then_expression(), "invalid type in ? then expression");
  }

  RECURSE(VisitWithExpectation(
      expr->else_expression(), expected_type_,
      "conditional else branch type mismatch with enclosing expression"));
  Type* else_type = StorageType(computed_type_);
  if (intish_ != 0 || !else_type->Is(cache_.kAsmComparable)) {
    FAIL(expr->else_expression(), "invalid type in ? else expression");
  }

  if (!then_type->Is(else_type) || !else_type->Is(then_type)) {
    FAIL(expr, "then and else expressions in ? must have the same type");
  }

  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) {
      SetType(var, Type::Any());
      info = GetVariableInfo(var);
    } else {
      FAIL(expr, "unbound variable");
    }
  }
  if (property_info_ != nullptr) {
    SetVariableInfo(var, property_info_);
    property_info_ = nullptr;
  }
  Type* type = Type::Intersect(info->type, expected_type_, zone());
  if (type->Is(cache_.kAsmInt)) type = cache_.kAsmInt;
  intish_ = 0;
  RECURSE(IntersectResult(expr, type));
}

void AsmTyper::VisitLiteral(Literal* expr, bool is_return) {
  intish_ = 0;
  Handle<Object> value = expr->value();
  if (value->IsNumber()) {
    int32_t i;
    uint32_t u;
    if (expr->raw_value()->ContainsDot()) {
      RECURSE(IntersectResult(expr, cache_.kAsmDouble));
    } else if (!is_return && value->ToUint32(&u)) {
      if (u <= 0x7fffffff) {
        RECURSE(IntersectResult(expr, cache_.kAsmFixnum));
      } else {
        RECURSE(IntersectResult(expr, cache_.kAsmUnsigned));
      }
    } else if (value->ToInt32(&i)) {
      RECURSE(IntersectResult(expr, cache_.kAsmSigned));
    } else {
      FAIL(expr, "illegal number");
    }
  } 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;
      }
    }
  }
  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 (expr->target()->IsVariableProxy()) {
    // Assignment to a local or context variable.
    VariableProxy* proxy = expr->target()->AsVariableProxy();
    if (intish_ != 0) {
      FAIL(expr, "intish or floatish assignment");
    }
    if (in_function_ && target_type->IsArray()) {
      FAIL(expr, "assignment to array variable");
    }
    expected_type_ = target_type;
    Variable* var = proxy->var();
    VariableInfo* info = GetVariableInfo(var);
    if (info == nullptr || info->type == nullptr) {
      if (var->mode() == TEMPORARY) {
        SetType(var, Type::Any());
        info = GetVariableInfo(var);
      } else {
        FAIL(proxy, "unbound variable");
      }
    }
    if (property_info_ != nullptr) {
      SetVariableInfo(var, property_info_);
      property_info_ = nullptr;
    }
    Type* type = Type::Intersect(info->type, expected_type_, zone());
    if (type->Is(cache_.kAsmInt)) type = cache_.kAsmInt;
    info->type = type;
    intish_ = 0;
    RECURSE(IntersectResult(proxy, type));
  } else if (expr->target()->IsProperty()) {
    // Assignment to a property: should be a heap assignment {H[x] = y}.
    int32_t value_intish = intish_;
    Property* property = expr->target()->AsProperty();
    RECURSE(VisitWithExpectation(property->obj(), Type::Any(),
                                 "bad propety object"));
    if (!computed_type_->IsArray()) {
      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
    // BinaryOperation* bin = expr->key()->AsBinaryOperation();
    // if (bin == nullptr || 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 == nullptr || 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));
    RECURSE(VisitWithExpectation(expr->key(), cache_.kAsmSigned,
                                 "must be integer"));
    RECURSE(IntersectResult(expr, type));
  } else {
    Literal* literal = expr->key()->AsLiteral();
    if (literal) {
      RECURSE(VisitWithExpectation(literal, cache_.kAsmSigned,
                                   "array index expected to be integer"));
    } else {
      int expected_shift = ElementShiftSize(type);
      if (expected_shift == 0) {
        RECURSE(Visit(expr->key()));
      } else {
        BinaryOperation* bin = expr->key()->AsBinaryOperation();
        if (bin == nullptr || 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 == nullptr || right->raw_value()->ContainsDot()) {
          FAIL(bin->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());
        if (expected_shift < 0 || n != expected_shift) {
          FAIL(right, "heap access shift must match element size");
        }
      }
      bounds_.set(expr->key(), 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 {
      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;                                                      \
  }                                                              \
  if (IsSIMDTypeObject(expr, #Name)) {                           \
    VariableInfo* info = stdlib_simd_##name##_constructor_type_; \
    SetResult(expr, info->type);                                 \
    property_info_ = info;                                       \
    return;                                                      \
  }
  SIMD128_TYPES(V)
#undef V
  if (IsStdlibObject(expr->obj())) {
    VisitLibraryAccess(&stdlib_types_, expr);
    return;
  }

  property_info_ = nullptr;

  // Only recurse at this point so that we avoid needing
  // stdlib.Math to have a real type.
  RECURSE(
      VisitWithExpectation(expr->obj(), Type::Any(), "bad property object"));

  // For heap view or function table access.
  if (computed_type_->IsArray()) {
    VisitHeapAccess(expr, false, nullptr);
    return;
  }

  VariableProxy* proxy = expr->obj()->AsVariableProxy();
  if (proxy != nullptr) {
    Variable* var = proxy->var();
    if (var->location() == VariableLocation::PARAMETER && var->index() == 1) {
      // foreign.x - Function represent as () -> Any
      if (Type::Any()->Is(expected_type_)) {
        SetResult(expr, Type::Function(Type::Any(), zone()));
      } else {
        SetResult(expr, expected_type_);
      }
      return;
    }
  }

  FAIL(expr, "invalid property access");
}

void AsmTyper::CheckPolymorphicStdlibArguments(
    enum StandardMember standard_member, ZoneList<Expression*>* args) {
  if (args->length() == 0) {
    return;
  }
  // Handle polymorphic stdlib functions specially.
  Expression* arg0 = args->at(0);
  Type* arg0_type = bounds_.get(arg0).upper;
  switch (standard_member) {
    case kMathFround: {
      if (!arg0_type->Is(cache_.kAsmFloat) &&
          !arg0_type->Is(cache_.kAsmDouble) &&
          !arg0_type->Is(cache_.kAsmSigned) &&
          !arg0_type->Is(cache_.kAsmUnsigned)) {
        FAIL(arg0, "illegal function argument type");
      }
      break;
    }
    case kMathCeil:
    case kMathFloor:
    case kMathSqrt: {
      if (!arg0_type->Is(cache_.kAsmFloat) &&
          !arg0_type->Is(cache_.kAsmDouble)) {
        FAIL(arg0, "illegal function argument type");
      }
      break;
    }
    case kMathAbs:
    case kMathMin:
    case kMathMax: {
      if (!arg0_type->Is(cache_.kAsmFloat) &&
          !arg0_type->Is(cache_.kAsmDouble) &&
          !arg0_type->Is(cache_.kAsmSigned)) {
        FAIL(arg0, "illegal function argument type");
      }
      if (args->length() > 1) {
        Type* other = Type::Intersect(bounds_.get(args->at(0)).upper,
                                      bounds_.get(args->at(1)).upper, zone());
        if (!other->Is(cache_.kAsmFloat) && !other->Is(cache_.kAsmDouble) &&
            !other->Is(cache_.kAsmSigned)) {
          FAIL(arg0, "function arguments types don't match");
        }
      }
      break;
    }
    default: { break; }
  }
}

void AsmTyper::VisitCall(Call* expr) {
  Type* expected_type = expected_type_;
  RECURSE(VisitWithExpectation(expr->expression(), Type::Any(),
                               "callee expected to be any"));
  StandardMember standard_member = kNone;
  VariableProxy* proxy = expr->expression()->AsVariableProxy();
  if (proxy) {
    standard_member = VariableAsStandardMember(proxy->var());
  }
  if (!in_function_ && (proxy == nullptr || standard_member != kMathFround)) {
    FAIL(expr, "calls forbidden outside function bodies");
  }
  if (proxy == nullptr && !expr->expression()->IsProperty()) {
    FAIL(expr, "calls must be to bound variables or function tables");
  }
  if (computed_type_->IsFunction()) {
    FunctionType* fun_type = computed_type_->AsFunction();
    Type* result_type = fun_type->Result();
    ZoneList<Expression*>* args = expr->arguments();
    if (Type::Any()->Is(result_type)) {
      // For foreign calls.
      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"));
        // Checking for asm extern types explicitly, as the type system
        // doesn't correctly check their inheritance relationship.
        if (!computed_type_->Is(cache_.kAsmSigned) &&
            !computed_type_->Is(cache_.kAsmFixnum) &&
            !computed_type_->Is(cache_.kAsmDouble)) {
          FAIL(arg,
               "foreign call argument expected to be int, double, or fixnum");
        }
      }
      intish_ = 0;
      bounds_.set(expr->expression(),
                  Bounds(Type::Function(Type::Any(), zone())));
      RECURSE(IntersectResult(expr, expected_type));
    } else {
      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"));
        if (standard_member != kNone && standard_member != kMathFround &&
            i == 0) {
          result_type = computed_type_;
        }
      }
      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");
  }
  if (left_intish > kMaxUncombinedAdditiveSteps) {
    FAIL(expr->left(), "too many consecutive additive ops");
  }

  RECURSE(
      VisitWithExpectation(expr->right(), Type::Number(),
                           "right bitwise operand expected to be a number"));
  int32_t right_intish = intish_;
  Type* right_type = computed_type_;
  if (!right_type->Is(right_expected)) {
    FAIL(expr->right(), "right bitwise operand expected to be an integer");
  }
  if (right_intish > kMaxUncombinedAdditiveSteps) {
    FAIL(expr->right(), "too many consecutive additive ops");
  }

  intish_ = 0;

  if (left_type->Is(cache_.kAsmFixnum) && right_type->Is(cache_.kAsmInt)) {
    left_type = right_type;
  }
  if (right_type->Is(cache_.kAsmFixnum) && left_type->Is(cache_.kAsmInt)) {
    right_type = left_type;
  }
  if (!conversion) {
    if (!left_type->Is(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);
    const AstValue* right_value = expr->right()->AsLiteral()->raw_value();
    if (expr->op() == Token::BIT_OR) {
      if (right_value->AsNumber() != 0.0 || right_value->ContainsDot()) {
        FAIL(expr, "illegal integer annotation value");
      }
    }
    if (expr->op() == Token::MUL) {
      if (right_value->AsNumber() != 1.0 && right_value->ContainsDot()) {
        FAIL(expr, "illegal double annotation value");
      }
    }
  }
  switch (expr->op()) {
    case Token::COMMA: {
      RECURSE(VisitWithExpectation(expr->left(), Type::Any(),
                                   "left comma operand expected to be any"));
      RECURSE(VisitWithExpectation(expr->right(), Type::Any(),
                                   "right comma operand expected to be any"));
      RECURSE(IntersectResult(expr, computed_type_));
      return;
    }
    case Token::OR:
    case Token::AND:
      FAIL(expr, "illegal logical operator");
    case Token::BIT_OR: {
      // BIT_OR allows Any since it is used as a type coercion.
      RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                          cache_.kAsmSigned, true));
      if (expr->left()->IsCall() && expr->op() == Token::BIT_OR &&
          Type::Number()->Is(bounds_.get(expr->left()).upper)) {
        // Force the return types of foreign functions.
        bounds_.set(expr->left(), Bounds(cache_.kAsmSigned));
      }
      if (in_function_ &&
          !bounds_.get(expr->left()).upper->Is(cache_.kAsmIntQ)) {
        FAIL(expr->left(), "intish required");
      }
      return;
    }
    case Token::BIT_XOR: {
      // Handle booleans specially to handle de-sugared !
      Literal* left = expr->left()->AsLiteral();
      if (left && left->value()->IsBoolean()) {
        if (left->ToBooleanIsTrue()) {
          bounds_.set(left, Bounds(cache_.kSingletonOne));
          RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmIntQ,
                                       "not operator expects an integer"));
          RECURSE(IntersectResult(expr, cache_.kAsmSigned));
          return;
        } else {
          FAIL(left, "unexpected false");
        }
      }
      // BIT_XOR allows Any since it is used as a type coercion (via ~~).
      RECURSE(VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmIntQ,
                                          cache_.kAsmSigned, true));
      return;
    }
    case Token::SHR: {
      RECURSE(VisitIntegerBitwiseOperator(
          expr, cache_.kAsmIntQ, cache_.kAsmIntQ, cache_.kAsmUnsigned, false));
      return;
    }
    case Token::SHL:
    case Token::SAR:
    case Token::BIT_AND: {
      RECURSE(VisitIntegerBitwiseOperator(
          expr, cache_.kAsmIntQ, cache_.kAsmIntQ, cache_.kAsmSigned, false));
      return;
    }
    case Token::ADD:
    case Token::SUB:
    case Token::MUL:
    case Token::DIV:
    case Token::MOD: {
      RECURSE(VisitWithExpectation(
          expr->left(), Type::Number(),
          "left arithmetic operand expected to be number"));
      Type* left_type = computed_type_;
      int32_t left_intish = intish_;
      RECURSE(VisitWithExpectation(
          expr->right(), Type::Number(),
          "right arithmetic operand expected to be number"));
      Type* right_type = computed_type_;
      int32_t right_intish = intish_;
      Type* type = Type::Union(left_type, right_type, zone());
      if (type->Is(cache_.kAsmInt)) {
        if (expr->op() == Token::MUL) {
          int32_t i;
          Literal* left = expr->left()->AsLiteral();
          Literal* right = expr->right()->AsLiteral();
          if (left != nullptr && left->value()->IsNumber() &&
              left->value()->ToInt32(&i)) {
            if (right_intish != 0) {
              FAIL(expr, "intish not allowed in multiply");
            }
          } else if (right != nullptr && right->value()->IsNumber() &&
                     right->value()->ToInt32(&i)) {
            if (left_intish != 0) {
              FAIL(expr, "intish not allowed in multiply");
            }
          } else {
            FAIL(expr, "multiply must be by an integer literal");
          }
          i = abs(i);
          if (i >= (1 << 20)) {
            FAIL(expr, "multiply must be by value in -2^20 < n < 2^20");
          }
          intish_ = i;
          RECURSE(IntersectResult(expr, cache_.kAsmInt));
          return;
        } else {
          intish_ = left_intish + right_intish + 1;
          if (expr->op() == Token::ADD || expr->op() == Token::SUB) {
            if (intish_ > kMaxUncombinedAdditiveSteps) {
              FAIL(expr, "too many consecutive additive ops");
            }
          } else {
            if (intish_ > kMaxUncombinedMultiplicativeSteps) {
              FAIL(expr, "too many consecutive multiplicative ops");
            }
          }
          RECURSE(IntersectResult(expr, cache_.kAsmInt));
          return;
        }
      } else if (expr->op() == Token::MUL && expr->right()->IsLiteral() &&
                 right_type->Is(cache_.kAsmDouble) &&
                 expr->right()->AsLiteral()->raw_value()->ContainsDot() &&
                 expr->right()->AsLiteral()->raw_value()->AsNumber() == 1.0) {
        // For unary +, expressed as x * 1.0
        if (expr->left()->IsCall() &&
            Type::Number()->Is(bounds_.get(expr->left()).upper)) {
          // Force the return types of foreign functions.
          bounds_.set(expr->left(), Bounds(cache_.kAsmDouble));
          left_type = bounds_.get(expr->left()).upper;
        }
        if (!(expr->left()->IsProperty() &&
              Type::Number()->Is(bounds_.get(expr->left()).upper))) {
          if (!left_type->Is(cache_.kAsmSigned) &&
              !left_type->Is(cache_.kAsmUnsigned) &&
              !left_type->Is(cache_.kAsmFixnum) &&
              !left_type->Is(cache_.kAsmFloatQ) &&
              !left_type->Is(cache_.kAsmDoubleQ)) {
            FAIL(
                expr->left(),
                "unary + only allowed on signed, unsigned, float?, or double?");
          }
        }
        RECURSE(IntersectResult(expr, cache_.kAsmDouble));
        return;
      } else if (expr->op() == Token::MUL && left_type->Is(cache_.kAsmDouble) &&
                 expr->right()->IsLiteral() &&
                 !expr->right()->AsLiteral()->raw_value()->ContainsDot() &&
                 expr->right()->AsLiteral()->raw_value()->AsNumber() == -1.0) {
        // For unary -, expressed as x * -1
        bounds_.set(expr->right(), Bounds(cache_.kAsmDouble));
        RECURSE(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");
        }
        RECURSE(IntersectResult(expr, cache_.kAsmFloat));
        intish_ = 1;
        return;
      } else if (type->Is(cache_.kAsmDouble)) {
        RECURSE(IntersectResult(expr, cache_.kAsmDouble));
        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");
  }

  RECURSE(
      VisitWithExpectation(expr->left(), Type::Number(),
                           "left comparison operand expected to be number"));
  Type* left_type = computed_type_;
  if (!left_type->Is(cache_.kAsmComparable)) {
    FAIL(expr->left(), "bad type on left side of comparison");
  }

  RECURSE(
      VisitWithExpectation(expr->right(), Type::Number(),
                           "right comparison operand expected to be number"));
  Type* right_type = computed_type_;
  if (!right_type->Is(cache_.kAsmComparable)) {
    FAIL(expr->right(), "bad type on right side of comparison");
  }

  if (!left_type->Is(right_type) && !right_type->Is(left_type)) {
    FAIL(expr, "left and right side of comparison must match");
  }

  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::VisitExportDeclaration(ExportDeclaration* decl) {
  FAIL(decl, "export 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());

  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
  // (which we cannot currently represent).
  Type* number_fn1_type = Type::Function(number_type, number_type, zone());
  Type* number_fn2_type =
      Type::Function(number_type, number_type, number_type, zone());

  struct Assignment {
    const char* name;
    StandardMember standard_member;
    Type* type;
  };

  const Assignment math[] = {{"PI", kMathPI, double_type},
                             {"E", kMathE, double_type},
                             {"LN2", kMathLN2, double_type},
                             {"LN10", kMathLN10, double_type},
                             {"LOG2E", kMathLOG2E, double_type},
                             {"LOG10E", kMathLOG10E, double_type},
                             {"SQRT2", kMathSQRT2, double_type},
                             {"SQRT1_2", kMathSQRT1_2, double_type},
                             {"imul", kMathImul, imul_type},
                             {"abs", kMathAbs, number_fn1_type},
                             {"ceil", kMathCeil, number_fn1_type},
                             {"floor", kMathFloor, number_fn1_type},
                             {"fround", kMathFround, fround_type},
                             {"pow", kMathPow, double_fn2_type},
                             {"exp", kMathExp, double_fn1_type},
                             {"log", kMathLog, double_fn1_type},
                             {"min", kMathMin, number_fn2_type},
                             {"max", kMathMax, number_fn2_type},
                             {"sqrt", kMathSqrt, number_fn1_type},
                             {"cos", kMathCos, double_fn1_type},
                             {"sin", kMathSin, double_fn1_type},
                             {"tan", kMathTan, double_fn1_type},
                             {"acos", kMathAcos, double_fn1_type},
                             {"asin", kMathAsin, double_fn1_type},
                             {"atan", kMathAtan, double_fn1_type},
                             {"atan2", kMathAtan2, double_fn2_type}};
  for (unsigned i = 0; i < arraysize(math); ++i) {
    stdlib_math_types_[math[i].name] = new (zone()) VariableInfo(math[i].type);
    stdlib_math_types_[math[i].name]->standard_member = math[i].standard_member;
  }
  stdlib_math_types_["fround"]->is_check_function = true;

  stdlib_types_["Infinity"] = new (zone()) VariableInfo(double_type);
  stdlib_types_["Infinity"]->standard_member = kInfinity;
  stdlib_types_["NaN"] = new (zone()) VariableInfo(double_type);
  stdlib_types_["NaN"]->standard_member = kNaN;
  Type* buffer_type = Type::Any();
#define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
  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"] = 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 =
      map->Lookup(variable, ComputePointerHash(variable));
  if (!entry && in_function_) {
    entry =
        global_variable_type_.Lookup(variable, ComputePointerHash(variable));
  }
  return entry ? reinterpret_cast<VariableInfo*>(entry->value) : nullptr;
}

AsmTyper::VariableInfo* AsmTyper::MakeVariableInfo(Variable* variable) {
  ZoneHashMap* map =
      in_function_ ? &local_variable_type_ : &global_variable_type_;
  ZoneHashMap::Entry* entry = map->LookupOrInsert(
      variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone()));
  if (!entry->value) entry->value = new (zone()) VariableInfo;
  return reinterpret_cast<VariableInfo*>(entry->value);
}

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