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

src/asmjs/asm-wasm-builder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
 #include <math.h>
 
+#include "src/asmjs/asm-types.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/wasm/switch-logic.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/codegen.h"
-#include "src/type-cache.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 #define RECURSE(call)               \
   do {                              \
     DCHECK(!HasStackOverflow());    \
     call;                           \
     if (HasStackOverflow()) return; \
@@ skipping 20 matching lines @@
         global_variables_(base::HashMap::PointersMatch,
                           ZoneHashMap::kDefaultHashMapCapacity,
                           ZoneAllocationPolicy(zone)),
         scope_(kModuleScope),
         builder_(new (zone) WasmModuleBuilder(zone)),
         current_function_builder_(nullptr),
         literal_(literal),
         isolate_(isolate),
         zone_(zone),
         typer_(typer),
-        cache_(TypeCache::Get()),
         breakable_blocks_(zone),
         foreign_variables_(zone),
         init_function_index_(0),
         foreign_init_function_index_(0),
         next_table_index_(0),
         function_tables_(base::HashMap::PointersMatch,
                          ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
-        imported_function_table_(this),
-        bounds_(typer->bounds()) {
+        imported_function_table_(this) {
     InitializeAstVisitor(isolate);
   }
 
   void InitializeInitFunction() {
     init_function_index_ = builder_->AddFunction();
     FunctionSig::Builder b(zone(), 0, 0);
     current_function_builder_ = builder_->FunctionAt(init_function_index_);
     current_function_builder_->SetSignature(b.Build());
     builder_->MarkStartFunction(init_function_index_);
     current_function_builder_ = nullptr;
@@ skipping 269 matching lines @@
     ZoneVector<BlockVisitor*> blocks(zone_);
     ZoneVector<int32_t> cases(zone_);
     ZoneMap<int, unsigned int> case_to_block(zone_);
     bool has_default = false;
     for (int i = case_count - 1; i >= 0; i--) {
       CaseClause* clause = clauses->at(i);
       blocks.push_back(new BlockVisitor(this, nullptr, kExprBlock, false));
       if (!clause->is_default()) {
         Literal* label = clause->label()->AsLiteral();
         Handle<Object> value = label->value();
-        DCHECK(value->IsNumber() &&
-               bounds_->get(label).upper->Is(cache_.kAsmSigned));
         int32_t label_value;
-        if (!value->ToInt32(&label_value)) {
-          UNREACHABLE();
-        }
+        bool label_is_i32 = value->ToInt32(&label_value);
+        DCHECK(value->IsNumber() && label_is_i32);
+        (void)label_is_i32;
         case_to_block[label_value] = i;
         cases.push_back(label_value);
       } else {
         DCHECK_EQ(i, case_count - 1);
         has_default = true;
       }
     }
     if (!has_default || case_count > 1) {
       int default_block = has_default ? case_count - 1 : case_count;
       BlockVisitor switch_logic_block(this, nullptr, kExprBlock, false);
@@ skipping 74 matching lines @@
     UNREACHABLE();
   }
 
   void VisitDebuggerStatement(DebuggerStatement* stmt) override {
     UNREACHABLE();
   }
 
   void VisitFunctionLiteral(FunctionLiteral* expr) override {
     Scope* scope = expr->scope();
     if (scope_ == kFuncScope) {
-      if (bounds_->get(expr).lower->IsFunction()) {
+      if (auto* func_type = typer_->TypeOf(expr)->AsFunctionType()) {
         // Build the signature for the function.
-        FunctionType* func_type = bounds_->get(expr).lower->AsFunction();
-        LocalType return_type = TypeFrom(func_type->Result());
+        LocalType return_type = TypeFrom(func_type->ReturnType());
+        const auto& arguments = func_type->Arguments();
         FunctionSig::Builder b(zone(), return_type == kAstStmt ? 0 : 1,
-                               func_type->Arity());
+                               arguments.size());
         if (return_type != kAstStmt) b.AddReturn(return_type);
         for (int i = 0; i < expr->parameter_count(); ++i) {
-          LocalType type = TypeFrom(func_type->Parameter(i));
+          LocalType type = TypeFrom(arguments[i]);
           DCHECK_NE(kAstStmt, type);
           b.AddParam(type);
           InsertParameter(scope->parameter(i), type, i);
         }
         current_function_builder_->SetSignature(b.Build());
       } else {
         UNREACHABLE();
       }
     }
     RECURSE(VisitStatements(expr->body()));
@@ skipping 85 matching lines @@
             LookupOrInsertLocal(var, var_type));
       }
     }
   }
 
   void VisitLiteral(Literal* expr) override {
     Handle<Object> value = expr->value();
     if (!value->IsNumber() || (scope_ != kFuncScope && scope_ != kInitScope)) {
       return;
     }
-    Type* type = bounds_->get(expr).upper;
-    if (type->Is(cache_.kAsmSigned)) {
+    AsmType* type = typer_->TypeOf(expr);
+    DCHECK_NE(type, AsmType::None());
+
+    if (type->IsA(AsmType::Signed())) {
       int32_t i = 0;
       if (!value->ToInt32(&i)) {
         UNREACHABLE();
       }
       byte code[] = {WASM_I32V(i)};
       current_function_builder_->EmitCode(code, sizeof(code));
-    } else if (type->Is(cache_.kAsmUnsigned) || type->Is(cache_.kAsmFixnum)) {
+    } else if (type->IsA(AsmType::Unsigned()) || type->IsA(AsmType::FixNum())) {
       uint32_t u = 0;
       if (!value->ToUint32(&u)) {
         UNREACHABLE();
       }
       int32_t i = static_cast<int32_t>(u);
       byte code[] = {WASM_I32V(i)};
       current_function_builder_->EmitCode(code, sizeof(code));
-    } else if (type->Is(cache_.kAsmDouble)) {
+    } else if (type->IsA(AsmType::Double())) {
       double val = expr->raw_value()->AsNumber();
       byte code[] = {WASM_F64(val)};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else {
       UNREACHABLE();
     }
   }
 
   void VisitRegExpLiteral(RegExpLiteral* expr) override { UNREACHABLE(); }
 
@@ skipping 25 matching lines @@
     current_function_builder_ = builder_->FunctionAt(init_function_index_);
     scope_ = kInitScope;
   }
 
   void UnLoadInitFunction() {
     scope_ = kModuleScope;
     current_function_builder_ = nullptr;
   }
 
   void AddFunctionTable(VariableProxy* table, ArrayLiteral* funcs) {
-    FunctionType* func_type =
-        bounds_->get(funcs).lower->AsArray()->Element()->AsFunction();
-    LocalType return_type = TypeFrom(func_type->Result());
+    auto* func_tbl_type = typer_->TypeOf(funcs)->AsFunctionTableType();
+    DCHECK_NOT_NULL(func_tbl_type);
+    auto* func_type = func_tbl_type->signature()->AsFunctionType();
+    const auto& arguments = func_type->Arguments();
+    LocalType return_type = TypeFrom(func_type->ReturnType());
     FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
-                             func_type->Arity());
+                             arguments.size());
     if (return_type != kAstStmt) {
-      sig.AddReturn(static_cast<LocalType>(return_type));
+      sig.AddReturn(return_type);
     }
-    for (int i = 0; i < func_type->Arity(); ++i) {
-      sig.AddParam(TypeFrom(func_type->Parameter(i)));
+    for (auto* arg : arguments) {
+      sig.AddParam(TypeFrom(arg));
     }
     uint32_t signature_index = builder_->AddSignature(sig.Build());
     InsertFunctionTable(table->var(), next_table_index_, signature_index);
     next_table_index_ += funcs->values()->length();
     for (int i = 0; i < funcs->values()->length(); ++i) {
       VariableProxy* func = funcs->values()->at(i)->AsVariableProxy();
       DCHECK_NOT_NULL(func);
       builder_->AddIndirectFunction(LookupOrInsertFunction(func->var()));
     }
   }
@@ skipping 140 matching lines @@
       } else {
         current_function_builder_->EmitSetLocal(
             LookupOrInsertLocal(var, var_type));
       }
     }
 
     Property* target_prop = expr->target()->AsProperty();
     if (target_prop != nullptr) {
       // Left hand side is a property access, i.e. the asm.js heap.
       if (TypeOf(expr->value()) == kAstF64 && expr->target()->IsProperty() &&
-          bounds_->get(expr->target()->AsProperty()->obj())
-              .lower->Is(cache_.kFloat32Array)) {
+          typer_->TypeOf(expr->target()->AsProperty()->obj())
+              ->IsA(AsmType::Float32Array())) {
         current_function_builder_->Emit(kExprF32ConvertF64);
       }
       WasmOpcode opcode;
       if (type == MachineType::Int8()) {
         opcode = kExprI32AsmjsStoreMem8;
       } else if (type == MachineType::Uint8()) {
         opcode = kExprI32AsmjsStoreMem8;
       } else if (type == MachineType::Int16()) {
         opcode = kExprI32AsmjsStoreMem16;
       } else if (type == MachineType::Uint16()) {
@@ skipping 19 matching lines @@
 
   void VisitAssignment(Assignment* expr) override {
     bool as_init = false;
     if (scope_ == kModuleScope) {
       Property* prop = expr->value()->AsProperty();
       if (prop != nullptr) {
         VariableProxy* vp = prop->obj()->AsVariableProxy();
         if (vp != nullptr && vp->var()->IsParameter() &&
             vp->var()->index() == 1) {
           VariableProxy* target = expr->target()->AsVariableProxy();
-          if (bounds_->get(target).lower->Is(Type::Function())) {
+          if (typer_->TypeOf(target)->AsFFIType() != nullptr) {
             const AstRawString* name =
                 prop->key()->AsLiteral()->AsRawPropertyName();
             imported_function_table_.AddImport(
                 target->var(), reinterpret_cast<const char*>(name->raw_data()),
                 name->length());
           }
         }
         // Property values in module scope don't emit code, so return.
         return;
       }
       ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
       if (funcs != nullptr &&
-          bounds_->get(funcs).lower->AsArray()->Element()->IsFunction()) {
+          typer_->TypeOf(funcs)
+              ->AsFunctionTableType()
+              ->signature()
+              ->AsFunctionType()) {
         VariableProxy* target = expr->target()->AsVariableProxy();
         DCHECK_NOT_NULL(target);
         AddFunctionTable(target, funcs);
         // Only add to the function table. No init needed.
         return;
       }
       if (expr->value()->IsCallNew()) {
         // No init code to emit for CallNew nodes.
         return;
       }
@@ skipping 25 matching lines @@
     if (!key_literal->value().is_null()) {
       Handle<Name> name =
           i::Object::ToName(isolate_, key_literal->value()).ToHandleChecked();
       LocalType type = is_float ? kAstF64 : kAstI32;
       foreign_variables_.push_back({name, var, type});
     }
   }
 
   void VisitPropertyAndEmitIndex(Property* expr, MachineType* mtype) {
     Expression* obj = expr->obj();
-    DCHECK_EQ(bounds_->get(obj).lower, bounds_->get(obj).upper);
-    Type* type = bounds_->get(obj).lower;
+    AsmType* type = typer_->TypeOf(obj);
     int size;
-    if (type->Is(cache_.kUint8Array)) {
+    if (type->IsA(AsmType::Uint8Array())) {
       *mtype = MachineType::Uint8();
       size = 1;
-    } else if (type->Is(cache_.kInt8Array)) {
+    } else if (type->IsA(AsmType::Int8Array())) {
       *mtype = MachineType::Int8();
       size = 1;
-    } else if (type->Is(cache_.kUint16Array)) {
+    } else if (type->IsA(AsmType::Uint16Array())) {
       *mtype = MachineType::Uint16();
       size = 2;
-    } else if (type->Is(cache_.kInt16Array)) {
+    } else if (type->IsA(AsmType::Int16Array())) {
       *mtype = MachineType::Int16();
       size = 2;
-    } else if (type->Is(cache_.kUint32Array)) {
+    } else if (type->IsA(AsmType::Uint32Array())) {
       *mtype = MachineType::Uint32();
       size = 4;
-    } else if (type->Is(cache_.kInt32Array)) {
+    } else if (type->IsA(AsmType::Int32Array())) {
       *mtype = MachineType::Int32();
       size = 4;
-    } else if (type->Is(cache_.kUint32Array)) {
+    } else if (type->IsA(AsmType::Uint32Array())) {
       *mtype = MachineType::Uint32();
       size = 4;
-    } else if (type->Is(cache_.kFloat32Array)) {
+    } else if (type->IsA(AsmType::Float32Array())) {
       *mtype = MachineType::Float32();
       size = 4;
-    } else if (type->Is(cache_.kFloat64Array)) {
+    } else if (type->IsA(AsmType::Float64Array())) {
       *mtype = MachineType::Float64();
       size = 8;
     } else {
       UNREACHABLE();
     }
     if (size == 1) {
       // Allow more general expression in byte arrays than the spec
       // strictly permits.
       // Early versions of Emscripten emit HEAP8[HEAP32[..]|0] in
       // places that strictly should be HEAP8[HEAP32[..]>>0].
@@ skipping 275 matching lines @@
         if (literal != nullptr) {
           // constant fold Math.fround(#const);
           if (literal->raw_value()->IsNumber()) {
             float val = static_cast<float>(literal->raw_value()->AsNumber());
             byte code[] = {WASM_F32(val)};
             current_function_builder_->EmitCode(code, sizeof(code));
             return true;
           }
         }
         VisitCallArgs(call);
-        switch (TypeIndexOf(args->at(0))) {
+        static const bool kDontIgnoreSign = false;
+        switch (TypeIndexOf(args->at(0), kDontIgnoreSign)) {
           case kInt32:
           case kFixnum:
             current_function_builder_->Emit(kExprF32SConvertI32);
             break;
           case kUint32:
             current_function_builder_->Emit(kExprF32UConvertI32);
             break;
           case kFloat32:
             break;
           case kFloat64:
@@ skipping 26 matching lines @@
       case Call::OTHER_CALL: {
         DCHECK_EQ(kFuncScope, scope_);
         VariableProxy* proxy = expr->expression()->AsVariableProxy();
         if (proxy != nullptr) {
           if (VisitStdlibFunction(expr, proxy)) {
             return;
           }
         }
         uint32_t index;
         VariableProxy* vp = expr->expression()->AsVariableProxy();
-        if (vp != nullptr &&
-            Type::Any()->Is(bounds_->get(vp).lower->AsFunction()->Result())) {
+        DCHECK_NOT_NULL(vp);
+        if (typer_->TypeOf(vp)->AsFFIType() != nullptr) {
           LocalType return_type = TypeOf(expr);
           ZoneList<Expression*>* args = expr->arguments();
           FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
                                    args->length());
           if (return_type != kAstStmt) {
             sig.AddReturn(return_type);
           }
           for (int i = 0; i < args->length(); ++i) {
             sig.AddParam(TypeOf(args->at(i)));
           }
@@ skipping 182 matching lines @@
   Expression* GetLeft(BinaryOperation* expr) {
     if (expr->op() == Token::BIT_XOR) {
       return expr->left()->AsBinaryOperation()->left();
     } else {
       return expr->left();
     }
   }
 
   void VisitBinaryOperation(BinaryOperation* expr) override {
     ConvertOperation convertOperation = MatchBinaryOperation(expr);
+    static const bool kDontIgnoreSign = false;
     if (convertOperation == kToDouble) {
       RECURSE(Visit(expr->left()));
-      TypeIndex type = TypeIndexOf(expr->left());
+      TypeIndex type = TypeIndexOf(expr->left(), kDontIgnoreSign);
       if (type == kInt32 || type == kFixnum) {
         current_function_builder_->Emit(kExprF64SConvertI32);
       } else if (type == kUint32) {
         current_function_builder_->Emit(kExprF64UConvertI32);
       } else if (type == kFloat32) {
         current_function_builder_->Emit(kExprF64ConvertF32);
       } else {
         UNREACHABLE();
       }
     } else if (convertOperation == kToInt) {
       RECURSE(Visit(GetLeft(expr)));
-      TypeIndex type = TypeIndexOf(GetLeft(expr));
+      TypeIndex type = TypeIndexOf(GetLeft(expr), kDontIgnoreSign);
       if (type == kFloat32) {
         current_function_builder_->Emit(kExprI32AsmjsSConvertF32);
       } else if (type == kFloat64) {
         current_function_builder_->Emit(kExprI32AsmjsSConvertF64);
       } else {
         UNREACHABLE();
       }
     } else if (convertOperation == kAsIs) {
       RECURSE(Visit(GetLeft(expr)));
     } else {
@@ skipping 69 matching lines @@
 
   enum TypeIndex {
     kInt32 = 0,
     kUint32 = 1,
     kFloat32 = 2,
     kFloat64 = 3,
     kFixnum = 4
   };
 
   TypeIndex TypeIndexOf(Expression* left, Expression* right, bool ignore_sign) {
-    TypeIndex left_index = TypeIndexOf(left);
-    TypeIndex right_index = TypeIndexOf(right);
+    TypeIndex left_index = TypeIndexOf(left, ignore_sign);
+    TypeIndex right_index = TypeIndexOf(right, ignore_sign);
     if (left_index == kFixnum) {
       left_index = right_index;
     }
     if (right_index == kFixnum) {
       right_index = left_index;
     }
     if (left_index == kFixnum && right_index == kFixnum) {
       left_index = kInt32;
       right_index = kInt32;
     }
-    DCHECK((left_index == right_index) ||
-           (ignore_sign && (left_index <= 1) && (right_index <= 1)));
+    if (left_index != right_index) {
+      DCHECK(ignore_sign && (left_index <= 1) && (right_index <= 1));
+    }
     return left_index;
   }
 
-  TypeIndex TypeIndexOf(Expression* expr) {
-    DCHECK_EQ(bounds_->get(expr).lower, bounds_->get(expr).upper);
-    Type* type = bounds_->get(expr).lower;
-    if (type->Is(cache_.kAsmFixnum)) {
+  TypeIndex TypeIndexOf(Expression* expr, bool ignore_sign) {
+    AsmType* type = typer_->TypeOf(expr);
+    if (type->IsA(AsmType::FixNum())) {
       return kFixnum;
-    } else if (type->Is(cache_.kAsmSigned)) {
-      return kInt32;
-    } else if (type->Is(cache_.kAsmUnsigned)) {
-      return kUint32;
-    } else if (type->Is(cache_.kAsmInt)) {
-      return kInt32;
-    } else if (type->Is(cache_.kAsmFloat)) {
-      return kFloat32;
-    } else if (type->Is(cache_.kAsmDouble)) {
-      return kFloat64;
-    } else {
-      UNREACHABLE();
+    }
+
+    if (type->IsA(AsmType::Signed())) {
       return kInt32;
     }
+
+    if (type->IsA(AsmType::Unsigned())) {
+      return kUint32;
+    }
+
+    if (type->IsA(AsmType::Intish())) {
+      if (!ignore_sign) {
+        // TODO(jpp): log a warning and move on.
+      }
+      return kInt32;
+    }
+
+    if (type->IsA(AsmType::Floatish())) {
+      return kFloat32;
+    }
+
+    if (type->IsA(AsmType::DoubleQ())) {
+      return kFloat64;
+    }
+
+    UNREACHABLE();
+    return kInt32;
   }
 
 #undef CASE
 #undef NON_SIGNED_INT
 #undef SIGNED
 #undef NON_SIGNED
 
   void VisitThisFunction(ThisFunction* expr) override { UNREACHABLE(); }
 
   void VisitDeclarations(ZoneList<Declaration*>* decls) override {
@@ skipping 82 matching lines @@
       uint32_t index = builder_->AddFunction();
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
                                         ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
-  LocalType TypeOf(Expression* expr) {
-    DCHECK_EQ(bounds_->get(expr).lower, bounds_->get(expr).upper);
-    return TypeFrom(bounds_->get(expr).lower);
-  }
+  LocalType TypeOf(Expression* expr) { return TypeFrom(typer_->TypeOf(expr)); }
 
-  LocalType TypeFrom(Type* type) {
-    if (type->Is(cache_.kAsmInt)) {
+  LocalType TypeFrom(AsmType* type) {
+    if (type->IsA(AsmType::Intish())) {
       return kAstI32;
-    } else if (type->Is(cache_.kAsmFloat)) {
+    }
+
+    if (type->IsA(AsmType::Floatish())) {
       return kAstF32;
-    } else if (type->Is(cache_.kAsmDouble)) {
+    }
+
+    if (type->IsA(AsmType::DoubleQ())) {
       return kAstF64;
-    } else {
-      return kAstStmt;
     }
+
+    return kAstStmt;
   }
 
   Zone* zone() { return zone_; }
 
   ZoneHashMap local_variables_;
   ZoneHashMap functions_;
   ZoneHashMap global_variables_;
   AsmScope scope_;
   WasmModuleBuilder* builder_;
   WasmFunctionBuilder* current_function_builder_;
   FunctionLiteral* literal_;
   Isolate* isolate_;
   Zone* zone_;
   AsmTyper* typer_;
-  TypeCache const& cache_;
   ZoneVector<std::pair<BreakableStatement*, bool>> breakable_blocks_;
   ZoneVector<ForeignVariable> foreign_variables_;
   uint32_t init_function_index_;
   uint32_t foreign_init_function_index_;
   uint32_t next_table_index_;
   ZoneHashMap function_tables_;
   ImportedFunctionTable imported_function_table_;
-  const AstTypeBounds* bounds_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
 };
 
 AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
                                FunctionLiteral* literal, AsmTyper* typer)
     : isolate_(isolate), zone_(zone), literal_(literal), typer_(typer) {}
 
 // TODO(aseemgarg): probably should take zone (to write wasm to) as input so
 // that zone in constructor may be thrown away once wasm module is written.
 ZoneBuffer* AsmWasmBuilder::Run(i::Handle<i::FixedArray>* foreign_args) {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, typer_);
   impl.Build();
   *foreign_args = impl.GetForeignArgs();
   ZoneBuffer* buffer = new (zone_) ZoneBuffer(zone_);
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8