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 57 matching lines @@
   void InitializeInitFunction() {
     unsigned char init[] = "__init__";
     init_function_index_ = builder_->AddFunction();
     current_function_builder_ = builder_->FunctionAt(init_function_index_);
     current_function_builder_->SetName(init, 8);
     current_function_builder_->ReturnType(kAstStmt);
     current_function_builder_->Exported(1);
     current_function_builder_ = nullptr;
   }
 
+  void AddStdlibImport(const char* name, int kind, int args) {
+    uint16_t index = builder_->AddFunction();
+    std_function_index_[kind] = index;
+    WasmFunctionBuilder* b = builder_->FunctionAt(index);
+    b->External(1);
+    b->SetName(reinterpret_cast<const unsigned char*>(name),
+               static_cast<int>(strlen(name)));
+    b->ReturnType(kAstF64);
+    for (int i = 0; i < args; ++i) {
+      b->AddParam(kAstF64);
+    }
+  }
+
+  void InitializeStdlibFunctions() {
+    for (int i = 0; i < AsmTyper::kStdlibMax; ++i) {
+      std_function_index_[i] = -1;
+    }
+  }
+
+  void AddStdlibFunction(int kind) {
+    const char* name = nullptr;
+    int args = 0;
+    switch (kind) {
+      case AsmTyper::kMathAcos:
+        name = "_acos";
+        args = 1;
+        break;
+      case AsmTyper::kMathAsin:
+        name = "_asin";
+        args = 1;
+        break;
+      case AsmTyper::kMathAtan:
+        name = "_atan";
+        args = 1;
+        break;
+      case AsmTyper::kMathCos:
+        name = "_cos";
+        args = 1;
+        break;
+      case AsmTyper::kMathSin:
+        name = "_sin";
+        args = 1;
+        break;
+      case AsmTyper::kMathTan:
+        name = "_tan";
+        args = 1;
+        break;
+      case AsmTyper::kMathExp:
+        name = "_exp";
+        args = 1;
+        break;
+      case AsmTyper::kMathLog:
+        name = "_log";
+        args = 1;
+        break;
+      case AsmTyper::kMathAtan2:
+        name = "_atan2";
+        args = 2;
+        break;
+      case AsmTyper::kMathPow:
+        name = "_pow";
+        args = 2;
+        break;
+    }
+    DCHECK(name != nullptr);
+    AddStdlibImport(name, kind, args);
+  }
+
+  void EmitStdlibCall(int kind) {
+    if (std_function_index_[kind] < 0) {
+      AddStdlibFunction(kind);
+    }
+    current_function_builder_->Emit(kExprCallFunction);
+    std::vector<uint8_t> index_arr =
+        UnsignedLEB128From(std_function_index_[kind]);
+    current_function_builder_->EmitCode(
+        &index_arr[0], static_cast<uint32_t>(index_arr.size()));
+  }
+
   void Compile() {
     InitializeInitFunction();
+    InitializeStdlibFunctions();
     RECURSE(VisitFunctionLiteral(literal_));
   }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK(!in_function_);
     DCHECK_NULL(current_function_builder_);
     uint16_t index = LookupOrInsertFunction(decl->proxy()->var());
     current_function_builder_ = builder_->FunctionAt(index);
@@ skipping 745 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.
+        EmitStdlibCall(AsmTyper::kMathAcos);
+        break;
       }
       case AsmTyper::kMathAsin: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathAsin);
+        break;
       }
       case AsmTyper::kMathAtan: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathAtan);
+        break;
       }
       case AsmTyper::kMathCos: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathCos);
+        break;
       }
       case AsmTyper::kMathSin: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathSin);
+        break;
       }
       case AsmTyper::kMathTan: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathTan);
+        break;
       }
       case AsmTyper::kMathExp: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathExp);
+        break;
       }
       case AsmTyper::kMathLog: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathLog);
+        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 11 matching lines @@
       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: {

[titzer, 2016/02/24 17:54:11]

We're going to need some more extensive tests for these stdlib functions. E.g.
we don't transform Math.abs calls into Float64Abs in TurboFan because of (I
think) a semantic difference. It's ok for integers but we should test reasonable
inputs for the floating point types.

[bradn, 2016/02/24 18:07:29]

Yeah this one is goofy, Math.abs is supposed to handle signed -> signed, but
Math.abs(-(1<<32)) seems to yield a value that's really an intish.

Agreed on the tests. I plan to go through these with a fine tooth comb for
boundary cases, but am focusing on bringing up embenchen for the moment.

-        // 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_I32(0)};

[titzer, 2016/02/24 17:54:11]

WASM_I8

[bradn, 2016/02/24 18:07:29]

Done.

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

[bradn, 2016/02/24 18:07:29]

Min and max have the same -(1<<31) issue it seems too, I'll ask Alon about it
later.

+          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.
+        EmitStdlibCall(AsmTyper::kMathAtan2);
+        break;
       }
       case AsmTyper::kMathPow: {
-        UNREACHABLE();
-        break;  // TODO(bradnelson): Implement as external.
+        EmitStdlibCall(AsmTyper::kMathPow);
+        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 522 matching lines @@
   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_;
+  int std_function_index_[AsmTyper::kStdlibMax];
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
 };
 
 AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
                                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_, typer_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8