PPC: [builtins] Introduce proper Float64Log1p, Float64Atan and Float64Atan2 operators.

Port 7ceed92a
Port 89d8c57b

Original commit message:

    Import base::ieee754::atan() and base::ieee754::atan2() from fdlibm and
    introduce Float64Atan and Float64Atan2 TurboFan operators based on those,
    similar to what we already did for Float64Log and Float64Log1p. Rewrite
    Math.atan() and Math.atan2() as TurboFan builtin and use the operators
    to also inline Math.atan() and Math.atan2() into optimized TurboFan functions.

    Import base::ieee754::log1p() from fdlibm and introduce a Float64Log1p
    TurboFan operator based on that, similar to what we do for Float64Log.
    Rewrite Math.log1p() as TurboFan builtin and use that operator to also
    inline Math.log1p() into optimized TurboFan functions.

    Also unify the handling of the special IEEE 754 functions somewhat in
    the TurboFan backends. At some point we can hopefully express this
    completely in the InstructionSelector (once we have an idea what to do
    with the ST(0) return issue on IA-32/X87).

    Drive-by-fix: Add some more test coverage for the log function.

R=bmeurer@chromium.org, joransiu@ca.ibm.com, jyan@ca.ibm.com, michael_dawson@ca.ibm.com, mbrandy@us.ibm.com

BUG=v8:5086,v8:5092,v8:5095
LOG=N

Review-Url: https://codereview.chromium.org/2061753002
Cr-Commit-Position: refs/heads/master@{#36935}

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

@@ -436,15 +436,33 @@ Condition FlagsConditionToCondition(FlagsCondition condition, ArchOpcode op) {
     DCHECK_EQ(LeaveRC, i.OutputRCBit());                                      \
   } while (0)
 
-#define ASSEMBLE_FLOAT_LOG()                                                \
-  do {                                                                      \
-    FrameScope scope(masm(), StackFrame::MANUAL);                           \
-    __ PrepareCallCFunction(0, 1, kScratchReg);                             \
-    __ MovToFloatParameter(i.InputDoubleRegister(0));                       \
-    __ CallCFunction(ExternalReference::ieee754_log_function(isolate()), 0, \
-                     1);                                                    \
-    __ MovFromFloatResult(i.OutputDoubleRegister());                        \
-    DCHECK_EQ(LeaveRC, i.OutputRCBit());                                    \
+#define ASSEMBLE_IEEE754_UNOP(name)                                            \
+  do {                                                                         \
+    /* TODO(bmeurer): We should really get rid of this special instruction, */ \
+    /* and generate a CallAddress instruction instead. */                      \
+    FrameScope scope(masm(), StackFrame::MANUAL);                              \
+    __ PrepareCallCFunction(0, 1, kScratchReg);                                \
+    __ MovToFloatParameter(i.InputDoubleRegister(0));                          \
+    __ CallCFunction(ExternalReference::ieee754_##name##_function(isolate()),  \
+                     0, 1);                                                    \
+    /* Move the result in the double result register. */                       \
+    __ MovFromFloatResult(i.OutputDoubleRegister());                           \
+    DCHECK_EQ(LeaveRC, i.OutputRCBit());                                       \
+  } while (0)
+
+#define ASSEMBLE_IEEE754_BINOP(name)                                           \
+  do {                                                                         \
+    /* TODO(bmeurer): We should really get rid of this special instruction, */ \
+    /* and generate a CallAddress instruction instead. */                      \
+    FrameScope scope(masm(), StackFrame::MANUAL);                              \
+    __ PrepareCallCFunction(0, 2, kScratchReg);                                \
+    __ MovToFloatParameters(i.InputDoubleRegister(0),                          \
+                           i.InputDoubleRegister(1));                          \
+    __ CallCFunction(ExternalReference::ieee754_##name##_function(isolate()),  \
+                     0, 2);                                                    \
+    /* Move the result in the double result register. */                       \
+    __ MovFromFloatResult(i.OutputDoubleRegister());                           \
+    DCHECK_EQ(LeaveRC, i.OutputRCBit());                                       \
   } while (0)
 
 #define ASSEMBLE_FLOAT_MAX(scratch_reg)                                       \
@@ -1239,10 +1257,17 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
       // and generate a CallAddress instruction instead.
       ASSEMBLE_FLOAT_MODULO();
       break;
-    case kPPC_LogDouble:
-      // TODO(bmeurer): We should really get rid of this special instruction,
-      // and generate a CallAddress instruction instead.
-      ASSEMBLE_FLOAT_LOG();
+    case kIeee754Float64Atan:
+      ASSEMBLE_IEEE754_UNOP(atan);
+      break;
+    case kIeee754Float64Atan2:
+      ASSEMBLE_IEEE754_BINOP(atan2);
+      break;
+    case kIeee754Float64Log:
+      ASSEMBLE_IEEE754_UNOP(log);
+      break;
+    case kIeee754Float64Log1p:
+      ASSEMBLE_IEEE754_UNOP(log1p);
       break;
     case kPPC_Neg:
       __ neg(i.OutputRegister(), i.InputRegister(0), LeaveOE, i.OutputRCBit());

src/compiler/ppc/instruction-codes-ppc.h

@@ -57,7 +57,6 @@ namespace compiler {
   V(PPC_ModU32)                    \
   V(PPC_ModU64)                    \
   V(PPC_ModDouble)                 \
-  V(PPC_LogDouble)                 \
   V(PPC_Neg)                       \
   V(PPC_NegDouble)                 \
   V(PPC_SqrtDouble)                \

src/compiler/ppc/instruction-scheduler-ppc.cc

@@ -59,7 +59,6 @@ int InstructionScheduler::GetTargetInstructionFlags(
     case kPPC_ModU32:
     case kPPC_ModU64:
     case kPPC_ModDouble:
-    case kPPC_LogDouble:
     case kPPC_Neg:
     case kPPC_NegDouble:
     case kPPC_SqrtDouble:

src/compiler/ppc/instruction-selector-ppc.cc

@@ -1310,16 +1310,24 @@ void InstructionSelector::VisitFloat64Abs(Node* node) {
   VisitRR(this, kPPC_AbsDouble, node);
 }
 
-void InstructionSelector::VisitFloat64Log(Node* node) {
-  PPCOperandGenerator g(this);
-  Emit(kPPC_LogDouble, g.DefineAsFixed(node, d1),
-       g.UseFixed(node->InputAt(0), d1))->MarkAsCall();
-}
-
 void InstructionSelector::VisitFloat32Sqrt(Node* node) {
   VisitRR(this, kPPC_SqrtDouble | MiscField::encode(1), node);
 }
 
+void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
+                                                  InstructionCode opcode) {
+  PPCOperandGenerator g(this);
+  Emit(opcode, g.DefineAsFixed(node, d1), g.UseFixed(node->InputAt(0), d1))
+       ->MarkAsCall();
+}
+
+void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
+                                                  InstructionCode opcode) {
+  PPCOperandGenerator g(this);
+  Emit(opcode, g.DefineAsFixed(node, d1),
+       g.UseFixed(node->InputAt(0), d1),
+       g.UseFixed(node->InputAt(1), d2))->MarkAsCall();
+}
 
 void InstructionSelector::VisitFloat64Sqrt(Node* node) {
   VisitRR(this, kPPC_SqrtDouble, node);