Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(612)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/asmjs/typing-asm.cc

Issue 2142333002: Refactor class declaration logic to the parser and runtime Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: non-inline ToName Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/asmjs/asm-wasm-builder.cc ('k') | src/ast/ast.h » ('j') | src/ast/ast.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/asmjs/typing-asm.cc
diff --git a/src/asmjs/typing-asm.cc b/src/asmjs/typing-asm.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8470f5c2fbe044d1e6da1824425d954e96aaad87
--- /dev/null
+++ b/src/asmjs/typing-asm.cc
@@ -0,0 +1,1602 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
adamk 2016/07/14 22:00:47 Did this file get accidentally added as part of so
bakkot 2016/07/14 22:46:01 Yup. Fixed.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#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"
+
+namespace v8 {
+namespace internal {
+
+#define FAIL(node, msg) \
+ do { \
+ valid_ = false; \
+ int line = node->position() == kNoSourcePosition \
+ ? -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),
+ 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.
+ 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_.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);
+ 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_.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");
+ }
+
+ RECURSE(VisitWithExpectation(
+ expr->then_expression(), expected_type_,
+ "conditional then branch type mismatch with enclosing expression"));
+ Type* then_type = StorageType(computed_type_);
+ int then_intish = intish_;
+
+ RECURSE(VisitWithExpectation(
+ expr->else_expression(), expected_type_,
+ "conditional else branch type mismatch with enclosing expression"));
+ Type* else_type = StorageType(computed_type_);
+ int else_intish = intish_;
+
+ if (then_intish != 0 || else_intish != 0 ||
+ !((then_type->Is(cache_.kAsmInt) && else_type->Is(cache_.kAsmInt)) ||
+ (then_type->Is(cache_.kAsmFloat) && else_type->Is(cache_.kAsmFloat)) ||
+ (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) {
+ 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();
+ if (!in_function_ && var->IsParameter()) {
+ FAIL(expr, "assignment to module parameter");
+ }
+ 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 int"));
+ RECURSE(IntersectResult(expr, type));
+ } else {
+ Literal* literal = expr->key()->AsLiteral();
+ if (literal) {
+ RECURSE(VisitWithExpectation(literal, cache_.kAsmUnsigned,
+ "array index expected to be unsigned"));
+ } 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_.kAsmInt,
+ "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_.kAsmFixnum,
+ "array shift expected to be Fixnum"));
+ 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_.kAsmUnsigned));
+ }
+ 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");
+ }
+ }
+ if (expr->op() == Token::MOD || expr->op() == Token::DIV) {
+ if (!((left_type->Is(cache_.kAsmSigned) &&
+ right_type->Is(cache_.kAsmSigned)) ||
+ (left_type->Is(cache_.kAsmUnsigned) &&
+ right_type->Is(cache_.kAsmUnsigned)))) {
+ FAIL(expr,
+ "left and right side of integer / or % "
+ "must match and be signed or unsigned");
+ }
+ }
+ 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_;
+ int left_intish = intish_;
+
+ RECURSE(
+ VisitWithExpectation(expr->right(), Type::Number(),
+ "right comparison operand expected to be number"));
+ Type* right_type = computed_type_;
+ int right_intish = intish_;
+
+ if (left_intish != 0 || right_intish != 0 ||
+ !((left_type->Is(cache_.kAsmUnsigned) &&
+ right_type->Is(cache_.kAsmUnsigned)) ||
+ (left_type->Is(cache_.kAsmSigned) &&
+ right_type->Is(cache_.kAsmSigned)) ||
+ (left_type->Is(cache_.kAsmFloat) && right_type->Is(cache_.kAsmFloat)) ||
+ (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::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
« no previous file with comments | « src/asmjs/asm-wasm-builder.cc ('k') | src/ast/ast.h » ('j') | src/ast/ast.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698