X87: [wasm] Use the Float64Max/Min machine operators to implement F64Max/Min.

src/compiler/x87/code-generator-x87.cc

 // Copyright 2013 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/compiler/code-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 173 matching lines @@
  public:
   OutOfLineLoadInteger(CodeGenerator* gen, Register result)
       : OutOfLineCode(gen), result_(result) {}
 
   void Generate() final { __ xor_(result_, result_); }
 
  private:
   Register const result_;
 };
 
-class OutOfLineLoadNaN final : public OutOfLineCode {
+class OutOfLineLoadFloat32NaN final : public OutOfLineCode {
  public:
-  OutOfLineLoadNaN(CodeGenerator* gen, X87Register result)
+  OutOfLineLoadFloat32NaN(CodeGenerator* gen, X87Register result)
       : OutOfLineCode(gen), result_(result) {}
 
   void Generate() final {
     DCHECK(result_.code() == 0);
     USE(result_);
     __ fstp(0);
-    __ push(Immediate(0xffffffff));

[ahaas, 2016/08/11 06:39:00]

I think you could also just push the default NaN instead of calculating it. The
default NaN for float64 is 0xfff8000000000000. For float32 it is 0xffc00000.

-    __ push(Immediate(0x7fffffff));
-    __ fld_d(MemOperand(esp, 0));
-    __ lea(esp, Operand(esp, kDoubleSize));
+    __ fldz();
+    __ fldz();
+    __ fdiv(1);
+    __ fstp(0);
+    __ lea(esp, Operand(esp, -kFloatSize));
+    __ fstp_s(MemOperand(esp, 0));
+    __ fld_s(MemOperand(esp, 0));
+    __ lea(esp, Operand(esp, kFloatSize));
   }
 
  private:
   X87Register const result_;
 };
 
+class OutOfLineLoadFloat64NaN final : public OutOfLineCode {
+ public:
+  OutOfLineLoadFloat64NaN(CodeGenerator* gen, X87Register result)
+      : OutOfLineCode(gen), result_(result) {}
+
+  void Generate() final {
+    DCHECK(result_.code() == 0);
+    USE(result_);
+    __ fstp(0);
+    __ fldz();
+    __ fldz();
+    __ fdiv(1);
+    __ fstp(0);
+  }
+
+ private:
+  X87Register const result_;
+};
 
 class OutOfLineTruncateDoubleToI final : public OutOfLineCode {
  public:
   OutOfLineTruncateDoubleToI(CodeGenerator* gen, Register result,
                              X87Register input)
       : OutOfLineCode(gen), result_(result), input_(input) {}
 
   void Generate() final {
     UNIMPLEMENTED();
     USE(result_);
@@ skipping 41 matching lines @@
   Register const object_;
   Operand const operand_;
   Register const value_;
   Register const scratch0_;
   Register const scratch1_;
   RecordWriteMode const mode_;
 };
 
 }  // namespace
 
-#define ASSEMBLE_CHECKED_LOAD_FLOAT(asm_instr)                        \
+#define ASSEMBLE_CHECKED_LOAD_FLOAT(asm_instr, OutOfLineLoadNaN)      \
   do {                                                                \
     auto result = i.OutputDoubleRegister();                           \
     auto offset = i.InputRegister(0);                                 \
     DCHECK(result.code() == 0);                                       \
     if (instr->InputAt(1)->IsRegister()) {                            \
       __ cmp(offset, i.InputRegister(1));                             \
     } else {                                                          \
       __ cmp(offset, i.InputImmediate(1));                            \
     }                                                                 \
     OutOfLineCode* ool = new (zone()) OutOfLineLoadNaN(this, result); \
@@ skipping 1003 matching lines @@
       if (FLAG_debug_code && FLAG_enable_slow_asserts) {
         __ VerifyX87StackDepth(1);
       }
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fld_d(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
 
-      auto ool = new (zone()) OutOfLineLoadNaN(this, i.OutputDoubleRegister());
+      auto ool =
+          new (zone()) OutOfLineLoadFloat64NaN(this, i.OutputDoubleRegister());
       __ j(parity_even, ool->entry());
       __ j(below, &done_compare, Label::kNear);
       __ j(above, &compare_swap, Label::kNear);
       __ push(eax);
       __ lea(esp, Operand(esp, -kDoubleSize));
       __ fld(1);
       __ fstp_d(Operand(esp, 0));
       __ mov(eax, MemOperand(esp, 4));
       __ and_(eax, Immediate(0x80000000));
       __ lea(esp, Operand(esp, kDoubleSize));
@@ skipping 14 matching lines @@
       if (FLAG_debug_code && FLAG_enable_slow_asserts) {
         __ VerifyX87StackDepth(1);
       }
       __ fstp(0);
       __ fld_d(MemOperand(esp, kDoubleSize));
       __ fld_d(MemOperand(esp, 0));
       __ fld(1);
       __ fld(1);
       __ FCmp();
 
-      auto ool = new (zone()) OutOfLineLoadNaN(this, i.OutputDoubleRegister());
+      auto ool =
+          new (zone()) OutOfLineLoadFloat64NaN(this, i.OutputDoubleRegister());
       __ j(parity_even, ool->entry());
       __ j(above, &done_compare, Label::kNear);
       __ j(below, &compare_swap, Label::kNear);
       __ push(eax);
       __ lea(esp, Operand(esp, -kDoubleSize));
       __ fld(0);
       __ fstp_d(Operand(esp, 0));
       __ mov(eax, MemOperand(esp, 4));
       __ and_(eax, Immediate(0x80000000));
       __ lea(esp, Operand(esp, kDoubleSize));
@@ skipping 547 matching lines @@
     case kCheckedLoadInt16:
       ASSEMBLE_CHECKED_LOAD_INTEGER(movsx_w);
       break;
     case kCheckedLoadUint16:
       ASSEMBLE_CHECKED_LOAD_INTEGER(movzx_w);
       break;
     case kCheckedLoadWord32:
       ASSEMBLE_CHECKED_LOAD_INTEGER(mov);
       break;
     case kCheckedLoadFloat32:
-      ASSEMBLE_CHECKED_LOAD_FLOAT(fld_s);
+      ASSEMBLE_CHECKED_LOAD_FLOAT(fld_s, OutOfLineLoadFloat32NaN);
       break;
     case kCheckedLoadFloat64:
-      ASSEMBLE_CHECKED_LOAD_FLOAT(fld_d);
+      ASSEMBLE_CHECKED_LOAD_FLOAT(fld_d, OutOfLineLoadFloat64NaN);
       break;
     case kCheckedStoreWord8:
       ASSEMBLE_CHECKED_STORE_INTEGER(mov_b);
       break;
     case kCheckedStoreWord16:
       ASSEMBLE_CHECKED_STORE_INTEGER(mov_w);
       break;
     case kCheckedStoreWord32:
       ASSEMBLE_CHECKED_STORE_INTEGER(mov);
       break;
@@ skipping 721 matching lines @@
     int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
     __ Nop(padding_size);
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8