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"
 
+// Required to get M_E etc. in MSVC.
+#if defined(_WIN32)
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
 #include "src/wasm/asm-wasm-builder.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; \
   } 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));

[aseemgarg, 2016/02/22 22:15:53]

move the EmitCode and return to outside of cases and use breaks instead. seems
more conventional way of writing switch.

[bradnelson, 2016/02/23 09:48:54]

Done.

+        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;
+        }
         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();

[aseemgarg, 2016/02/22 22:15:53]

This doesn't seem quite right. Stdlib constants would show up as binary
operations. So, these checks should be part of the if above. 

[bradnelson, 2016/02/23 09:48:54]

So unlike foreign globals, stdlib functions come in without a type declaration:
var pi = stdlib.Math.PI;

So this is skipping these, since there's no init code to emit.
Updated comment.

Also I've refactored to merge with the item below for clarity.

+      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 =
@@ skipping 156 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.
+        // TODO(bradnelson): Change wasm to match Math.min in asm.js mode.
+        if (call_type == kAstF32) {
+          current_function_builder_->Emit(kExprF32Min);
+        } else if (call_type == kAstF64) {
+          current_function_builder_->Emit(kExprF64Min);
+        } else {
+          UNREACHABLE();
+        }
+        break;
+      }
+      case AsmTyper::kMathMax: {
+        // TODO(bradnelson): Handle signed.
+        // TODO(bradnelson): Change wasm to match Math.max in asm.js mode.
+        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: {
+        current_function_builder_->Emit(kExprI32Mul);
+        break;
+      }
+      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.

[aseemgarg, 2016/02/22 22:15:53]

The visiting of args should be done in the visit call it self. This function
should emit the opcode and then rely on common code in visitCall to deal with
args.

[bradnelson, 2016/02/23 09:48:55]

So sharing the later call is tricky, as Fround wants to be able to pick out
literals as a special case.
I've refactored calling the arguments into a shared method.

+    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