Add wasm internal opcodes for asm.js stdlib functions we're missing.

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
@@ skipping 828 matching lines @@
     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.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Acos);
+        break;
       }
       case AsmTyper::kMathAsin: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Asin);
+        break;
       }
       case AsmTyper::kMathAtan: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Atan);
+        break;
       }
       case AsmTyper::kMathCos: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Cos);
+        break;
       }
       case AsmTyper::kMathSin: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Sin);
+        break;
       }
       case AsmTyper::kMathTan: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Tan);
+        break;
       }
       case AsmTyper::kMathExp: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Exp);
+        break;
       }
       case AsmTyper::kMathLog: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Log);
+        break;
       }
       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;
@@ skipping 12 matching lines @@
         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) {
+        // TODO(bradnelson): Should this be cast to float?
+        if (call_type == kAstI32) {
+          current_function_builder_->Emit(kExprIfElse);
+          current_function_builder_->Emit(kExprI32LtS);
+          Visit(args->at(0));
+          byte code[] = {WASM_I8(0)};
+          current_function_builder_->EmitCode(code, sizeof(code));
+          current_function_builder_->Emit(kExprI32Sub);
+          current_function_builder_->EmitCode(code, sizeof(code));
+          Visit(args->at(0));
+        } else 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) {
+        if (call_type == kAstI32) {
+          current_function_builder_->Emit(kExprIfElse);
+          current_function_builder_->Emit(kExprI32LeS);
+          Visit(args->at(0));
+          Visit(args->at(1));
+        } else 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) {
+        if (call_type == kAstI32) {
+          current_function_builder_->Emit(kExprIfElse);
+          current_function_builder_->Emit(kExprI32GtS);
+          Visit(args->at(0));
+          Visit(args->at(1));
+        } else 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.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Atan2);
+        break;
       }
       case AsmTyper::kMathPow: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        DCHECK_EQ(kAstF64, call_type);
+        current_function_builder_->Emit(kExprF64Pow);
+        break;
       }
       case AsmTyper::kMathImul: {
         current_function_builder_->Emit(kExprI32Mul);
         break;
       }
       case AsmTyper::kMathFround: {
         DCHECK(args->length() == 1);
         Literal* literal = args->at(0)->AsLiteral();
         if (literal != nullptr) {
           if (literal->raw_value()->IsNumber()) {
@@ skipping 274 matching lines @@
         BINOP_CASE(Token::SHL, Shl, NON_SIGNED_INT_BINOP, true);
         BINOP_CASE(Token::SAR, ShrS, NON_SIGNED_INT_BINOP, true);
         BINOP_CASE(Token::SHR, ShrU, NON_SIGNED_INT_BINOP, true);
         case Token::MOD: {
           TypeIndex type = TypeIndexOf(expr->left(), expr->right(), false);
           if (type == kInt32) {
             current_function_builder_->Emit(kExprI32RemS);
           } else if (type == kUint32) {
             current_function_builder_->Emit(kExprI32RemU);
           } else if (type == kFloat64) {
-            ModF64(expr);
+            current_function_builder_->Emit(kExprF64Mod);
             return;
           } else {
             UNREACHABLE();
           }
           break;
         }
         case Token::COMMA: {
           current_function_builder_->EmitWithU8(kExprBlock, 2);
           break;
         }
         default:
           UNREACHABLE();
       }
       RECURSE(Visit(expr->left()));
       RECURSE(Visit(expr->right()));
     }
   }
 
-  void ModF64(BinaryOperation* expr) {
-    current_function_builder_->EmitWithU8(kExprBlock, 3);
-    uint16_t index_0 = current_function_builder_->AddLocal(kAstF64);
-    uint16_t index_1 = current_function_builder_->AddLocal(kAstF64);
-    current_function_builder_->Emit(kExprSetLocal);
-    AddLeb128(index_0, true);
-    RECURSE(Visit(expr->left()));
-    current_function_builder_->Emit(kExprSetLocal);
-    AddLeb128(index_1, true);
-    RECURSE(Visit(expr->right()));
-    current_function_builder_->Emit(kExprF64Sub);
-    current_function_builder_->Emit(kExprGetLocal);
-    AddLeb128(index_0, true);
-    current_function_builder_->Emit(kExprF64Mul);
-    current_function_builder_->Emit(kExprGetLocal);
-    AddLeb128(index_1, true);
-    // Use trunc instead of two casts
-    current_function_builder_->Emit(kExprF64SConvertI32);
-    current_function_builder_->Emit(kExprI32SConvertF64);
-    current_function_builder_->Emit(kExprF64Div);
-    current_function_builder_->Emit(kExprGetLocal);
-    AddLeb128(index_0, true);
-    current_function_builder_->Emit(kExprGetLocal);
-    AddLeb128(index_1, true);
-  }
-
   void AddLeb128(uint32_t index, bool is_local) {
     std::vector<uint8_t> index_vec = UnsignedLEB128From(index);
     if (is_local) {
       uint32_t pos_of_index[1] = {0};
       current_function_builder_->EmitCode(
           &index_vec[0], static_cast<uint32_t>(index_vec.size()), pos_of_index,
           1);
     } else {
       current_function_builder_->EmitCode(
           &index_vec[0], static_cast<uint32_t>(index_vec.size()));
@@ skipping 210 matching lines @@
 // that zone in constructor may be thrown away once wasm module is written.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   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