Add asm.js stdlib portion implementable as wasm opcodes.

src/wasm/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"
 
 #include "src/wasm/asm-wasm-builder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
@@ skipping 10 matching lines @@
   do {                              \
     DCHECK(!HasStackOverflow());    \
     call;                           \
     if (HasStackOverflow()) return; \
   } while (false)
 
 
 class AsmWasmBuilderImpl : public AstVisitor {
  public:
   AsmWasmBuilderImpl(Isolate* isolate, Zone* zone, FunctionLiteral* literal,
-                     Handle<Object> foreign)
+                     Handle<Object> foreign, AsmTyper* typer)
       : local_variables_(HashMap::PointersMatch,
                          ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
         functions_(HashMap::PointersMatch, ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
         global_variables_(HashMap::PointersMatch,
                           ZoneHashMap::kDefaultHashMapCapacity,
                           ZoneAllocationPolicy(zone)),
         in_function_(false),
         is_set_op_(false),
         marking_exported(false),
         builder_(new (zone) WasmModuleBuilder(zone)),
         current_function_builder_(nullptr),
         literal_(literal),
         isolate_(isolate),
         zone_(zone),
         foreign_(foreign),
+        typer_(typer),
         cache_(TypeCache::Get()),
         breakable_blocks_(zone),
         block_size_(0),
         init_function_index_(0),
         next_table_index_(0),
         function_tables_(HashMap::PointersMatch,
                          ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
         imported_function_table_(this) {
     InitializeAstVisitor(isolate);
@@ skipping 305 matching lines @@
   }
 
   void VisitConditional(Conditional* expr) {
     DCHECK(in_function_);
     current_function_builder_->Emit(kExprIfElse);
     RECURSE(Visit(expr->condition()));
     RECURSE(Visit(expr->then_expression()));
     RECURSE(Visit(expr->else_expression()));
   }
 
+  bool VisitStdlibConstant(Variable* var) {
+    AsmTyper::StandardMember standard_object =
+        typer_->VariableAsStandardMember(var);
+    switch (standard_object) {
+      case AsmTyper::kInfinity: {
+        double infinity = std::numeric_limits<double>::infinity();
+        byte code[] = {WASM_F64(infinity)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kNaN: {
+        double nan = std::numeric_limits<double>::signaling_NaN();
+        byte code[] = {WASM_F64(nan)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathE: {
+        byte code[] = {WASM_F64(M_E)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathLN10: {
+        byte code[] = {WASM_F64(M_LN10)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathLN2: {
+        byte code[] = {WASM_F64(M_LN2)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathLOG10E: {
+        byte code[] = {WASM_F64(M_LOG10E)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathLOG2E: {
+        byte code[] = {WASM_F64(M_LOG2E)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathPI: {
+        byte code[] = {WASM_F64(M_PI)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathSQRT1_2: {
+        byte code[] = {WASM_F64(M_SQRT1_2)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      case AsmTyper::kMathSQRT2: {
+        byte code[] = {WASM_F64(M_SQRT2)};
+        current_function_builder_->EmitCode(code, sizeof(code));
+        return true;
+      }
+      default: { break; }
+    }
+    return false;
+  }
+
   void VisitVariableProxy(VariableProxy* expr) {
     if (in_function_) {
       Variable* var = expr->var();
       if (is_set_op_) {
         if (var->IsContextSlot()) {
           current_function_builder_->Emit(kExprStoreGlobal);
         } else {
           current_function_builder_->Emit(kExprSetLocal);
         }
         is_set_op_ = false;
       } else {
+        if (VisitStdlibConstant(var)) {
+          return;

[aseemgarg, 2016/02/17 19:44:06]

get rid of the return and instead make the condition for var->IsContextSlot an
"else if". 

[bradn, 2016/02/19 07:16:52]

But I'm returning because I don't actually want to get the GetLocal/Global below
this.

+        }
         if (var->IsContextSlot()) {
           current_function_builder_->Emit(kExprLoadGlobal);
         } else {
           current_function_builder_->Emit(kExprGetLocal);
         }
       }
       LocalType var_type = TypeOf(expr);
       DCHECK_NE(kAstStmt, var_type);
       if (var->IsContextSlot()) {
         AddLeb128(LookupOrInsertGlobal(var, var_type), false);
@@ skipping 187 matching lines @@
           DCHECK(binop->right()->IsLiteral());
           DCHECK_EQ(0.0, binop->right()->AsLiteral()->raw_value()->AsNumber());
           DCHECK(!binop->right()->AsLiteral()->raw_value()->ContainsDot());
           VisitForeignVariable(false, prop);
         } else {
           UNREACHABLE();
         }
         UnLoadInitFunction();
         return;
       }
+      Property* prop = expr->value()->AsProperty();
+      if (prop != nullptr) {
+        if (TypeOf(expr->value()) != kAstStmt) {
+          // Assume it's part of stdlib.
+          return;
+        }
+      }
       // TODO(bradnelson): Get rid of this.
       if (TypeOf(expr->value()) == kAstStmt) {
         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 (target->bounds().lower->Is(Type::Function())) {
-              const AstRawString* name =
-                  prop->key()->AsLiteral()->AsRawPropertyName();
-              imported_function_table_.AddImport(
-                  target->var(), name->raw_data(), name->length());
+          if (vp != nullptr && vp->var()->IsParameter()) {

[aseemgarg, 2016/02/17 19:44:06]

what's the change here?

[bradn, 2016/02/19 07:16:52]

Oops, dropped.

+            fprintf(stderr, "%d\n", vp->var()->index());

[aseemgarg, 2016/02/17 19:44:06]

get rid of fprintf

[bradn, 2016/02/19 07:16:52]

Done.

+            if (vp->var()->index() == 1) {
+              VariableProxy* target = expr->target()->AsVariableProxy();
+              if (target->bounds().lower->Is(Type::Function())) {
+                const AstRawString* name =
+                    prop->key()->AsLiteral()->AsRawPropertyName();
+                imported_function_table_.AddImport(
+                    target->var(), name->raw_data(), name->length());
+              }
             }
           }
         }
         ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
         if (funcs != nullptr &&
             funcs->bounds().lower->AsArray()->Element()->IsFunction()) {
           VariableProxy* target = expr->target()->AsVariableProxy();
           DCHECK_NOT_NULL(target);
           AddFunctionTable(target, funcs);
         }
@@ skipping 143 matching lines @@
         current_function_builder_->Emit(kExprI32And);
         byte code[] = {WASM_I8(~(size - 1))};
         current_function_builder_->EmitCode(code, sizeof(code));
         RECURSE(Visit(binop->left()));
         return;
       }
     }
     UNREACHABLE();
   }
 
+  bool VisitStdlibFunction(Call* call, VariableProxy* expr) {
+    Variable* var = expr->var();
+    AsmTyper::StandardMember standard_object =
+        typer_->VariableAsStandardMember(var);
+    ZoneList<Expression*>* args = call->arguments();
+    LocalType call_type = TypeOf(call);
+    switch (standard_object) {
+      case AsmTyper::kNone: {
+        return false;
+      }
+      case AsmTyper::kMathAcos: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathAsin: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathAtan: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathCos: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathSin: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathTan: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathExp: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathLog: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathCeil: {
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Ceil);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Ceil);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathFloor: {
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Floor);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Floor);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathSqrt: {
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Sqrt);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Sqrt);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathAbs: {
+        // TODO(bradnelson): Handle signed.
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Abs);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Abs);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathMin: {
+        // TODO(bradnelson): Handle signed.
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Min);

[titzer, 2016/02/17 09:49:33]

Can you double check that the JS min/max correspond exactly to the WASM min/max?
I seem to recall there might be a difference.

[bradn, 2016/02/19 07:16:53]

Yes there is a difference around NaNs
I intend to gate the behavior for these opcodes on it being an asm module.
But will defer to a separate change. Added a TODO.

+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Min);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathMax: {
+        // TODO(bradnelson): Handle signed.
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Max);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Max);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathAtan2: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathPow: {
+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement as external.
+      }
+      case AsmTyper::kMathImul: {

[titzer, 2016/02/17 09:49:33]

Should be a simple kExprI32Mul.

[bradn, 2016/02/19 07:16:53]

Done.

+        UNREACHABLE();
+        break;  // TODO(bradnelson): Implement this inline.
+      }
+      case AsmTyper::kMathFround: {
+        DCHECK(args->length() == 1);
+        Literal* literal = args->at(0)->AsLiteral();
+        if (literal != NULL) {
+          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;
+          }
+        }
+        break;
+      }
+      default: { break; }
+    }
+    // Visit arguments.
+    for (int i = 0; i < args->length(); ++i) {
+      Expression* arg = args->at(i);
+      Visit(arg);
+    }
+    return true;
+  }
+
   void VisitCall(Call* expr) {
     Call::CallType call_type = expr->GetCallType(isolate_);
     switch (call_type) {
       case Call::OTHER_CALL: {
         DCHECK(in_function_);
+        VariableProxy* proxy = expr->expression()->AsVariableProxy();
+        if (proxy != NULL) {
+          if (VisitStdlibFunction(expr, proxy)) {
+            return;
+          }
+        }
         uint16_t index;
         VariableProxy* vp = expr->expression()->AsVariableProxy();
         if (vp != nullptr &&
             Type::Any()->Is(vp->bounds().lower->AsFunction()->Result())) {
           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);
@@ skipping 476 matching lines @@
   ZoneHashMap global_variables_;
   bool in_function_;
   bool is_set_op_;
   bool marking_exported;
   WasmModuleBuilder* builder_;
   WasmFunctionBuilder* current_function_builder_;
   FunctionLiteral* literal_;
   Isolate* isolate_;
   Zone* zone_;
   Handle<Object> foreign_;
+  AsmTyper* typer_;
   TypeCache const& cache_;
   ZoneVector<std::pair<BreakableStatement*, bool>> breakable_blocks_;
   int block_size_;
   uint16_t init_function_index_;
   uint32_t next_table_index_;
   ZoneHashMap function_tables_;
   ImportedFunctionTable imported_function_table_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
 };
 
 AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
-                               FunctionLiteral* literal, Handle<Object> foreign)
-    : isolate_(isolate), zone_(zone), literal_(literal), foreign_(foreign) {}
+                               FunctionLiteral* literal, Handle<Object> foreign,
+                               AsmTyper* typer)
+    : isolate_(isolate),
+      zone_(zone),
+      literal_(literal),
+      foreign_(foreign),
+      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.
 WasmModuleIndex* AsmWasmBuilder::Run() {
-  AsmWasmBuilderImpl impl(isolate_, zone_, literal_, foreign_);
+  AsmWasmBuilderImpl impl(isolate_, zone_, literal_, foreign_, typer_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8