[builtins] Introduce proper Float64Log2 and Float64Log10 operators.

BUG=v8:5095

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

src/assembler.cc

@@ -1638,6 +1638,16 @@ ExternalReference ExternalReference::ieee754_log1p_function(Isolate* isolate) {
       Redirect(isolate, FUNCTION_ADDR(base::ieee754::log1p), BUILTIN_FP_CALL));
 }
 
+ExternalReference ExternalReference::ieee754_log2_function(Isolate* isolate) {
+  return ExternalReference(
+      Redirect(isolate, FUNCTION_ADDR(base::ieee754::log2), BUILTIN_FP_CALL));
+}
+
+ExternalReference ExternalReference::ieee754_log10_function(Isolate* isolate) {
+  return ExternalReference(
+      Redirect(isolate, FUNCTION_ADDR(base::ieee754::log10), BUILTIN_FP_CALL));
+}
+
 ExternalReference ExternalReference::math_exp_constants(int constant_index) {
   DCHECK(math_exp_data_initialized);
   return ExternalReference(

src/assembler.h

@@ -1046,6 +1046,8 @@ class ExternalReference BASE_EMBEDDED {
   static ExternalReference ieee754_atan2_function(Isolate* isolate);
   static ExternalReference ieee754_log_function(Isolate* isolate);
   static ExternalReference ieee754_log1p_function(Isolate* isolate);
+  static ExternalReference ieee754_log2_function(Isolate* isolate);
+  static ExternalReference ieee754_log10_function(Isolate* isolate);
 
   static ExternalReference math_exp_constants(int constant_index);
   static ExternalReference math_exp_log_table();

src/base/ieee754.h

@@ -24,6 +24,12 @@ double log(double x);
 // accurate even if the value of |x| is near zero.
 double log1p(double x);
 
+// Return the base 2 logarithm of |x|.
+double log2(double x);
+
+// Return the base 10 logarithm of |x|.
+double log10(double x);
+
 }  // namespace ieee754
 }  // namespace base
 }  // namespace v8

src/bootstrapper.cc

@@ -1685,6 +1685,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
         SimpleInstallFunction(math, "log", Builtins::kMathLog, 1, true);
     native_context()->set_math_log(*math_log);
     SimpleInstallFunction(math, "log1p", Builtins::kMathLog1p, 1, true);
+    SimpleInstallFunction(math, "log2", Builtins::kMathLog2, 1, true);
+    SimpleInstallFunction(math, "log10", Builtins::kMathLog10, 1, true);
     SimpleInstallFunction(math, "max", Builtins::kMathMax, 2, false);
     SimpleInstallFunction(math, "min", Builtins::kMathMin, 2, false);
     SimpleInstallFunction(math, "round", Builtins::kMathRound, 1, true);

src/builtins.cc

@@ -2503,6 +2503,30 @@ void Builtins::Generate_MathLog1p(CodeStubAssembler* assembler) {
   assembler->Return(result);
 }
 
+// ES6 section 20.2.2.23 Math.log2 ( x )
+void Builtins::Generate_MathLog2(CodeStubAssembler* assembler) {
+  using compiler::Node;
+
+  Node* x = assembler->Parameter(1);
+  Node* context = assembler->Parameter(4);
+  Node* x_value = assembler->TruncateTaggedToFloat64(context, x);
+  Node* value = assembler->Float64Log2(x_value);
+  Node* result = assembler->ChangeFloat64ToTagged(value);
+  assembler->Return(result);
+}
+
+// ES6 section 20.2.2.22 Math.log10 ( x )
+void Builtins::Generate_MathLog10(CodeStubAssembler* assembler) {
+  using compiler::Node;
+
+  Node* x = assembler->Parameter(1);
+  Node* context = assembler->Parameter(4);
+  Node* x_value = assembler->TruncateTaggedToFloat64(context, x);
+  Node* value = assembler->Float64Log10(x_value);
+  Node* result = assembler->ChangeFloat64ToTagged(value);
+  assembler->Return(result);
+}
+
 // ES6 section 20.2.2.28 Math.round ( x )
 void Builtins::Generate_MathRound(CodeStubAssembler* assembler) {
   Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Round);

src/builtins.h

@@ -323,6 +323,8 @@ inline bool operator&(BuiltinExtraArguments lhs, BuiltinExtraArguments rhs) {
   V(MathFloor, 2)                     \
   V(MathLog, 2)                       \
   V(MathLog1p, 2)                     \
+  V(MathLog2, 2)                      \
+  V(MathLog10, 2)                     \
   V(MathRound, 2)                     \
   V(MathSqrt, 2)                      \
   V(MathTrunc, 2)                     \
@@ -638,6 +640,10 @@ class Builtins {
   static void Generate_MathLog(CodeStubAssembler* assembler);
   // ES6 section 20.2.2.21 Math.log ( x )
   static void Generate_MathLog1p(CodeStubAssembler* assembler);
+
+  static void Generate_MathLog2(CodeStubAssembler* assembler);
+  static void Generate_MathLog10(CodeStubAssembler* assembler);
+
   enum class MathMaxMinKind { kMax, kMin };
   static void Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind);
   // ES6 section 20.2.2.24 Math.max ( value1, value2 , ...values )

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

@@ -715,6 +715,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kArmAdd:
       __ add(i.OutputRegister(), i.InputRegister(0), i.InputOperand2(1),
              i.OutputSBit());

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

@@ -819,6 +819,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kArm64Float32RoundDown:
       __ Frintm(i.OutputFloat32Register(), i.InputFloat32Register(0));
       break;

src/compiler/code-assembler.h

@@ -110,6 +110,8 @@ class Schedule;
   V(Float64Atan)                        \
   V(Float64Log)                         \
   V(Float64Log1p)                       \
+  V(Float64Log2)                        \
+  V(Float64Log10)                       \
   V(Float64Neg)                         \
   V(Float64Sqrt)                        \
   V(Float64ExtractLowWord32)            \

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

@@ -661,6 +661,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kIA32Add:
       if (HasImmediateInput(instr, 1)) {
         __ add(i.InputOperand(0), i.InputImmediate(1));

src/compiler/instruction-codes.h

@@ -92,7 +92,9 @@ enum class RecordWriteMode { kValueIsMap, kValueIsPointer, kValueIsAny };
   V(Ieee754Float64Atan)                   \
   V(Ieee754Float64Atan2)                  \
   V(Ieee754Float64Log)                    \
-  V(Ieee754Float64Log1p)
+  V(Ieee754Float64Log1p)                  \
+  V(Ieee754Float64Log2)                   \
+  V(Ieee754Float64Log10)
 
 #define ARCH_OPCODE_LIST(V)  \
   COMMON_ARCH_OPCODE_LIST(V) \

src/compiler/instruction-scheduler.cc

@@ -228,6 +228,8 @@ int InstructionScheduler::GetInstructionFlags(const Instruction* instr) const {
     case kIeee754Float64Atan2:
     case kIeee754Float64Log:
     case kIeee754Float64Log1p:
+    case kIeee754Float64Log2:
+    case kIeee754Float64Log10:
       return kNoOpcodeFlags;
 
     case kArchStackPointer:

src/compiler/instruction-selector.cc

@@ -1142,6 +1142,10 @@ void InstructionSelector::VisitNode(Node* node) {
       return MarkAsFloat64(node), VisitFloat64Log(node);
     case IrOpcode::kFloat64Log1p:
       return MarkAsFloat64(node), VisitFloat64Log1p(node);
+    case IrOpcode::kFloat64Log2:
+      return MarkAsFloat64(node), VisitFloat64Log2(node);
+    case IrOpcode::kFloat64Log10:
+      return MarkAsFloat64(node), VisitFloat64Log10(node);
     case IrOpcode::kFloat64Sqrt:
       return MarkAsFloat64(node), VisitFloat64Sqrt(node);
     case IrOpcode::kFloat64Equal:
@@ -1263,6 +1267,14 @@ void InstructionSelector::VisitFloat64Log1p(Node* node) {
   VisitFloat64Ieee754Unop(node, kIeee754Float64Log1p);
 }
 
+void InstructionSelector::VisitFloat64Log2(Node* node) {
+  VisitFloat64Ieee754Unop(node, kIeee754Float64Log2);
+}
+
+void InstructionSelector::VisitFloat64Log10(Node* node) {
+  VisitFloat64Ieee754Unop(node, kIeee754Float64Log10);
+}
+
 void InstructionSelector::EmitTableSwitch(const SwitchInfo& sw,
                                           InstructionOperand& index_operand) {
   OperandGenerator g(this);

src/compiler/js-builtin-reducer.cc

@@ -259,6 +259,28 @@ Reduction JSBuiltinReducer::ReduceMathMin(Node* node) {
   return NoChange();
 }
 
+// ES6 section 20.2.2.23 Math.log2 ( x )
+Reduction JSBuiltinReducer::ReduceMathLog2(Node* node) {
+  JSCallReduction r(node);
+  if (r.InputsMatchOne(Type::Number())) {
+    // Math.log2(a:number) -> NumberLog(a)
+    Node* value = graph()->NewNode(simplified()->NumberLog2(), r.left());
+    return Replace(value);
+  }
+  return NoChange();
+}
+
+// ES6 section 20.2.2.22 Math.log10 ( x )
+Reduction JSBuiltinReducer::ReduceMathLog10(Node* node) {
+  JSCallReduction r(node);
+  if (r.InputsMatchOne(Type::Number())) {
+    // Math.log10(a:number) -> NumberLog10(a)
+    Node* value = graph()->NewNode(simplified()->NumberLog10(), r.left());
+    return Replace(value);
+  }
+  return NoChange();
+}
+
 // ES6 section 20.2.2.28 Math.round ( x )
 Reduction JSBuiltinReducer::ReduceMathRound(Node* node) {
   JSCallReduction r(node);
@@ -341,6 +363,12 @@ Reduction JSBuiltinReducer::Reduce(Node* node) {
     case kMathLog1p:
       reduction = ReduceMathLog1p(node);
       break;
+    case kMathLog2:
+      reduction = ReduceMathLog2(node);
+      break;
+    case kMathLog10:
+      reduction = ReduceMathLog10(node);
+      break;
     case kMathMax:
       reduction = ReduceMathMax(node);
       break;

src/compiler/js-builtin-reducer.h

@@ -38,6 +38,8 @@ class JSBuiltinReducer final : public AdvancedReducer {
   Reduction ReduceMathImul(Node* node);
   Reduction ReduceMathLog(Node* node);
   Reduction ReduceMathLog1p(Node* node);
+  Reduction ReduceMathLog2(Node* node);
+  Reduction ReduceMathLog10(Node* node);
   Reduction ReduceMathMax(Node* node);
   Reduction ReduceMathMin(Node* node);
   Reduction ReduceMathRound(Node* node);

src/compiler/machine-operator-reducer.cc

@@ -412,6 +412,16 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
       if (m.HasValue()) return ReplaceFloat64(base::ieee754::log1p(m.Value()));
       break;
     }
+    case IrOpcode::kFloat64Log2: {
+      Float64Matcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceFloat64(base::ieee754::log2(m.Value()));
+      break;
+    }
+    case IrOpcode::kFloat64Log10: {
+      Float64Matcher m(node->InputAt(0));
+      if (m.HasValue()) return ReplaceFloat64(base::ieee754::log10(m.Value()));
+      break;
+    }
     case IrOpcode::kChangeFloat32ToFloat64: {
       Float32Matcher m(node->InputAt(0));
       if (m.HasValue()) return ReplaceFloat64(m.Value());

src/compiler/machine-operator.cc

@@ -159,6 +159,8 @@ MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
   V(Float64Atan2, Operator::kNoProperties, 2, 0, 1)                           \
   V(Float64Log, Operator::kNoProperties, 1, 0, 1)                             \
   V(Float64Log1p, Operator::kNoProperties, 1, 0, 1)                           \
+  V(Float64Log2, Operator::kNoProperties, 1, 0, 1)                            \
+  V(Float64Log10, Operator::kNoProperties, 1, 0, 1)                           \
   V(Float64Add, Operator::kCommutative, 2, 0, 1)                              \
   V(Float64Sub, Operator::kNoProperties, 2, 0, 1)                             \
   V(Float64SubPreserveNan, Operator::kNoProperties, 2, 0, 1)                  \

src/compiler/machine-operator.h

@@ -375,6 +375,8 @@ class MachineOperatorBuilder final : public ZoneObject {
   // Floating point logarithm (double-precision).
   const Operator* Float64Log();
   const Operator* Float64Log1p();
+  const Operator* Float64Log2();
+  const Operator* Float64Log10();
 
   // Floating point bit representation.
   const Operator* Float64ExtractLowWord32();

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

@@ -753,6 +753,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kMipsAdd:
       __ Addu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
       break;

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

@@ -762,6 +762,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kMips64Add:
       __ Addu(i.OutputRegister(), i.InputRegister(0), i.InputOperand(1));
       break;

src/compiler/opcodes.h

@@ -205,6 +205,8 @@
   V(NumberAtan2)                      \
   V(NumberLog)                        \
   V(NumberLog1p)                      \
+  V(NumberLog2)                       \
+  V(NumberLog10)                      \
   V(NumberRound)                      \
   V(NumberSqrt)                       \
   V(NumberTrunc)                      \
@@ -371,6 +373,8 @@
   V(Float64Atan2)               \
   V(Float64Log)                 \
   V(Float64Log1p)               \
+  V(Float64Log2)                \
+  V(Float64Log10)               \
   V(Float64Sqrt)                \
   V(Float64RoundDown)           \
   V(Float32RoundUp)             \

src/compiler/raw-machine-assembler.h

@@ -466,6 +466,8 @@ class RawMachineAssembler {
   }
   Node* Float64Log(Node* a) { return AddNode(machine()->Float64Log(), a); }
   Node* Float64Log1p(Node* a) { return AddNode(machine()->Float64Log1p(), a); }
+  Node* Float64Log2(Node* a) { return AddNode(machine()->Float64Log2(), a); }
+  Node* Float64Log10(Node* a) { return AddNode(machine()->Float64Log10(), a); }
   Node* Float64Sqrt(Node* a) { return AddNode(machine()->Float64Sqrt(), a); }
   Node* Float64Equal(Node* a, Node* b) {
     return AddNode(machine()->Float64Equal(), a, b);

src/compiler/representation-change.cc

@@ -677,6 +677,10 @@ const Operator* RepresentationChanger::Float64OperatorFor(
       return machine()->Float64Log();
     case IrOpcode::kNumberLog1p:
       return machine()->Float64Log1p();
+    case IrOpcode::kNumberLog2:
+      return machine()->Float64Log2();
+    case IrOpcode::kNumberLog10:
+      return machine()->Float64Log10();
     case IrOpcode::kNumberSqrt:
       return machine()->Float64Sqrt();
     case IrOpcode::kNumberSilenceNaN:

src/compiler/simplified-lowering.cc

@@ -1443,7 +1443,9 @@ class RepresentationSelector {
       }
       case IrOpcode::kNumberAtan:
       case IrOpcode::kNumberLog:
-      case IrOpcode::kNumberLog1p: {
+      case IrOpcode::kNumberLog1p:
+      case IrOpcode::kNumberLog2:
+      case IrOpcode::kNumberLog10: {
         VisitUnop(node, UseInfo::TruncatingFloat64(),
                   MachineRepresentation::kFloat64);
         if (lower()) NodeProperties::ChangeOp(node, Float64Op(node));

src/compiler/simplified-operator.cc

@@ -256,6 +256,8 @@ CompareOperationHints::Hint CompareOperationHintOf(const Operator* op) {
   V(NumberAtan2, Operator::kNoProperties, 2)               \
   V(NumberLog, Operator::kNoProperties, 1)                 \
   V(NumberLog1p, Operator::kNoProperties, 1)               \
+  V(NumberLog2, Operator::kNoProperties, 1)                \
+  V(NumberLog10, Operator::kNoProperties, 1)               \
   V(NumberRound, Operator::kNoProperties, 1)               \
   V(NumberSqrt, Operator::kNoProperties, 1)                \
   V(NumberTrunc, Operator::kNoProperties, 1)               \

src/compiler/simplified-operator.h

@@ -183,6 +183,8 @@ class SimplifiedOperatorBuilder final : public ZoneObject {
   const Operator* NumberAtan2();
   const Operator* NumberLog();
   const Operator* NumberLog1p();
+  const Operator* NumberLog2();
+  const Operator* NumberLog10();
   const Operator* NumberRound();
   const Operator* NumberSqrt();
   const Operator* NumberTrunc();

src/compiler/typer.cc

@@ -1804,6 +1804,10 @@ Type* Typer::Visitor::TypeNumberLog(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeNumberLog1p(Node* node) { return Type::Number(); }
 
+Type* Typer::Visitor::TypeNumberLog2(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeNumberLog10(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeNumberRound(Node* node) {
   return TypeUnaryOp(node, NumberRound);
 }
@@ -2559,6 +2563,10 @@ Type* Typer::Visitor::TypeFloat64Log(Node* node) { return Type::Number(); }
 
 Type* Typer::Visitor::TypeFloat64Log1p(Node* node) { return Type::Number(); }
 
+Type* Typer::Visitor::TypeFloat64Log2(Node* node) { return Type::Number(); }
+
+Type* Typer::Visitor::TypeFloat64Log10(Node* node) { return Type::Number(); }
+
 Type* Typer::Visitor::TypeFloat64Sqrt(Node* node) { return Type::Number(); }
 
 

src/compiler/verifier.cc

@@ -755,6 +755,8 @@ void Verifier::Visitor::Check(Node* node) {
     case IrOpcode::kNumberAtan:
     case IrOpcode::kNumberLog:
     case IrOpcode::kNumberLog1p:
+    case IrOpcode::kNumberLog2:
+    case IrOpcode::kNumberLog10:
     case IrOpcode::kNumberRound:
     case IrOpcode::kNumberSqrt:
     case IrOpcode::kNumberTrunc:
@@ -1070,6 +1072,8 @@ void Verifier::Visitor::Check(Node* node) {
     case IrOpcode::kFloat64Atan2:
     case IrOpcode::kFloat64Log:
     case IrOpcode::kFloat64Log1p:
+    case IrOpcode::kFloat64Log2:
+    case IrOpcode::kFloat64Log10:
     case IrOpcode::kFloat64Sqrt:
     case IrOpcode::kFloat32RoundDown:
     case IrOpcode::kFloat64RoundDown:

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

@@ -879,6 +879,12 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     case kIeee754Float64Log1p:
       ASSEMBLE_IEEE754_UNOP(log1p);
       break;
+    case kIeee754Float64Log2:
+      ASSEMBLE_IEEE754_UNOP(log2);
+      break;
+    case kIeee754Float64Log10:
+      ASSEMBLE_IEEE754_UNOP(log10);
+      break;
     case kX64Add32:
       ASSEMBLE_BINOP(addl);
       break;

src/external-reference-table.cc

@@ -75,6 +75,10 @@ ExternalReferenceTable::ExternalReferenceTable(Isolate* isolate) {
       "base::ieee754::log");
   Add(ExternalReference::ieee754_log1p_function(isolate).address(),
       "base::ieee754::log1p");
+  Add(ExternalReference::ieee754_log2_function(isolate).address(),
+      "base::ieee754::log2");
+  Add(ExternalReference::ieee754_log10_function(isolate).address(),
+      "base::ieee754::log10");
   Add(ExternalReference::store_buffer_top(isolate).address(),
       "store_buffer_top");
   Add(ExternalReference::address_of_the_hole_nan().address(), "the_hole_nan");

src/objects.h

@@ -6589,6 +6589,8 @@ class Script: public Struct {
   V(Math, abs, MathAbs)                                     \
   V(Math, log, MathLog)                                     \
   V(Math, log1p, MathLog1p)                                 \
+  V(Math, log2, MathLog2)                                   \
+  V(Math, log10, MathLog10)                                 \
   V(Math, exp, MathExp)                                     \
   V(Math, sqrt, MathSqrt)                                   \
   V(Math, pow, MathPow)                                     \

src/third_party/fdlibm/fdlibm.js

@@ -757,187 +757,6 @@ function MathTanh(x) {
   return (x >= 0) ? z : -z;
 }
 
-// ES6 draft 09-27-13, section 20.2.2.21.
-// Return the base 10 logarithm of x
-//
-// Method :
-//      Let log10_2hi = leading 40 bits of log10(2) and
-//          log10_2lo = log10(2) - log10_2hi,
-//          ivln10   = 1/log(10) rounded.
-//      Then
-//              n = ilogb(x),
-//              if(n<0)  n = n+1;
-//              x = scalbn(x,-n);
-//              log10(x) := n*log10_2hi + (n*log10_2lo + ivln10*log(x))
-//
-// Note 1:
-//      To guarantee log10(10**n)=n, where 10**n is normal, the rounding
-//      mode must set to Round-to-Nearest.
-// Note 2:
-//      [1/log(10)] rounded to 53 bits has error .198 ulps;
-//      log10 is monotonic at all binary break points.
-//
-// Special cases:
-//      log10(x) is NaN if x < 0;
-//      log10(+INF) is +INF; log10(0) is -INF;
-//      log10(NaN) is that NaN;
-//      log10(10**N) = N  for N=0,1,...,22.
-//
-
-define IVLN10 = 4.34294481903251816668e-01;
-define LOG10_2HI = 3.01029995663611771306e-01;
-define LOG10_2LO = 3.69423907715893078616e-13;
-
-function MathLog10(x) {
-  x = x * 1;  // Convert to number.
-  var hx = %_DoubleHi(x);
-  var lx = %_DoubleLo(x);
-  var k = 0;
-
-  if (hx < 0x00100000) {
-    // x < 2^-1022
-    // log10(+/- 0) = -Infinity.
-    if (((hx & 0x7fffffff) | lx) === 0) return -INFINITY;
-    // log10 of negative number is NaN.
-    if (hx < 0) return NaN;
-    // Subnormal number. Scale up x.
-    k -= 54;
-    x *= TWO54;
-    hx = %_DoubleHi(x);
-    lx = %_DoubleLo(x);
-  }
-
-  // Infinity or NaN.
-  if (hx >= 0x7ff00000) return x;
-
-  k += (hx >> 20) - 1023;
-  var i = (k & 0x80000000) >>> 31;
-  hx = (hx & 0x000fffff) | ((0x3ff - i) << 20);
-  var y = k + i;
-  x = %_ConstructDouble(hx, lx);
-
-  var z = y * LOG10_2LO + IVLN10 * %math_log(x);
-  return z + y * LOG10_2HI;
-}
-
-
-// ES6 draft 09-27-13, section 20.2.2.22.
-// Return the base 2 logarithm of x
-//
-// fdlibm does not have an explicit log2 function, but fdlibm's pow
-// function does implement an accurate log2 function as part of the
-// pow implementation.  This extracts the core parts of that as a
-// separate log2 function.
-
-// Method:
-// Compute log2(x) in two pieces:
-// log2(x) = w1 + w2
-// where w1 has 53-24 = 29 bits of trailing zeroes.
-
-define DP_H = 5.84962487220764160156e-01;
-define DP_L = 1.35003920212974897128e-08;
-
-// Polynomial coefficients for (3/2)*(log2(x) - 2*s - 2/3*s^3)
-define LOG2_1 = 5.99999999999994648725e-01;
-define LOG2_2 = 4.28571428578550184252e-01;
-define LOG2_3 = 3.33333329818377432918e-01;
-define LOG2_4 = 2.72728123808534006489e-01;
-define LOG2_5 = 2.30660745775561754067e-01;
-define LOG2_6 = 2.06975017800338417784e-01;
-
-// cp = 2/(3*ln(2)). Note that cp_h + cp_l is cp, but with more accuracy.
-define CP = 9.61796693925975554329e-01;
-define CP_H = 9.61796700954437255859e-01;
-define CP_L = -7.02846165095275826516e-09;
-// 2^53
-define TWO53 = 9007199254740992; 
-
-function MathLog2(x) {
-  x = x * 1;  // Convert to number.
-  var ax = MathAbs(x);
-  var hx = %_DoubleHi(x);
-  var lx = %_DoubleLo(x);
-  var ix = hx & 0x7fffffff;
-
-  // Handle special cases.
-  // log2(+/- 0) = -Infinity
-  if ((ix | lx) == 0) return -INFINITY;
-
-  // log(x) = NaN, if x < 0
-  if (hx < 0) return NaN;
-
-  // log2(Infinity) = Infinity, log2(NaN) = NaN
-  if (ix >= 0x7ff00000) return x;
-
-  var n = 0;
-
-  // Take care of subnormal number.
-  if (ix < 0x00100000) {
-    ax *= TWO53;
-    n -= 53;
-    ix = %_DoubleHi(ax);
-  }
-
-  n += (ix >> 20) - 0x3ff;
-  var j = ix & 0x000fffff;
-
-  // Determine interval.
-  ix = j | 0x3ff00000;  // normalize ix.
-
-  var bp = 1;
-  var dp_h = 0;
-  var dp_l = 0;
-  if (j > 0x3988e) {  // |x| > sqrt(3/2)
-    if (j < 0xbb67a) {  // |x| < sqrt(3)
-      bp = 1.5;
-      dp_h = DP_H;
-      dp_l = DP_L;
-    } else {
-      n += 1;
-      ix -= 0x00100000;
-    }
-  }
- 
-  ax = %_ConstructDouble(ix, %_DoubleLo(ax));
-
-  // Compute ss = s_h + s_l = (x - 1)/(x+1) or (x - 1.5)/(x + 1.5)
-  var u = ax - bp;
-  var v = 1 / (ax + bp);
-  var ss = u * v;
-  var s_h = %_ConstructDouble(%_DoubleHi(ss), 0);
-
-  // t_h = ax + bp[k] High
-  var t_h = %_ConstructDouble(%_DoubleHi(ax + bp), 0)
-  var t_l = ax - (t_h - bp);
-  var s_l = v * ((u - s_h * t_h) - s_h * t_l);
-
-  // Compute log2(ax)
-  var s2 = ss * ss;
-  var r = s2 * s2 * (LOG2_1 + s2 * (LOG2_2 + s2 * (LOG2_3 + s2 * (
-                     LOG2_4 + s2 * (LOG2_5 + s2 * LOG2_6)))));
-  r += s_l * (s_h + ss);
-  s2  = s_h * s_h;
-  t_h = %_ConstructDouble(%_DoubleHi(3.0 + s2 + r), 0);
-  t_l = r - ((t_h - 3.0) - s2);
-  // u + v = ss * (1 + ...)
-  u = s_h * t_h;
-  v = s_l * t_h + t_l * ss;
-
-  // 2 / (3 * log(2)) * (ss + ...)
-  var p_h = %_ConstructDouble(%_DoubleHi(u + v), 0);
-  var p_l = v - (p_h - u);
-  var z_h = CP_H * p_h;
-  var z_l = CP_L * p_h + p_l * CP + dp_l;
-
-  // log2(ax) = (ss + ...) * 2 / (3 * log(2)) = n + dp_h + z_h + z_l
-  var t = n;
-  var t1 = %_ConstructDouble(%_DoubleHi(((z_h + z_l) + dp_h) + t), 0);
-  var t2 = z_l - (((t1 - t) - dp_h) - z_h);
-
-  // t1 + t2 = log2(ax), sum up because we do not care about extra precision.
-  return t1 + t2;
-}
-
 //-------------------------------------------------------------------
 
 utils.InstallFunctions(GlobalMath, DONT_ENUM, [
@@ -947,8 +766,6 @@ utils.InstallFunctions(GlobalMath, DONT_ENUM, [
   "sinh", MathSinh,
   "cosh", MathCosh,
   "tanh", MathTanh,
-  "log10", MathLog10,
-  "log2", MathLog2,
   "expm1", MathExpm1
 ]);
 

test/cctest/compiler/test-run-machops.cc

@@ -5546,6 +5546,35 @@ TEST(RunFloat64Log1p) {
   FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log1p(*i), m.Call(*i)); }
 }
 
+TEST(RunFloat64Log2) {
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+  m.Return(m.Float64Log2(m.Parameter(0)));
+  CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+  CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+  CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+  CHECK(std::isnan(m.Call(-1.0)));
+  CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+  CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+  CHECK_DOUBLE_EQ(0.0, m.Call(1.0));
+  CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+                  m.Call(std::numeric_limits<double>::infinity()));
+  FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log2(*i), m.Call(*i)); }
+}
+
+TEST(RunFloat64Log10) {
+  BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
+  m.Return(m.Float64Log10(m.Parameter(0)));
+  CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN())));
+  CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN())));
+  CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity())));
+  CHECK(std::isnan(m.Call(-1.0)));
+  CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0));
+  CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0));
+  CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(),
+                  m.Call(std::numeric_limits<double>::infinity()));
+  FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log10(*i), m.Call(*i)); }
+}
+
 static double two_30 = 1 << 30;             // 2^30 is a smi boundary.
 static double two_52 = two_30 * (1 << 22);  // 2^52 is a precision boundary.
 static double kValues[] = {0.1,

test/unittests/base/ieee754-unittest.cc

@@ -91,6 +91,33 @@ TEST(Ieee754, Log1p) {
   EXPECT_EQ(0.8109302162163288, log1p(1.25));
 }
 
+TEST(Ieee754, Log2) {
+  EXPECT_THAT(log2(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+  EXPECT_THAT(log2(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+  EXPECT_THAT(log2(-std::numeric_limits<double>::infinity()), IsNaN());
+  EXPECT_THAT(log2(-1.0), IsNaN());
+  EXPECT_EQ(-std::numeric_limits<double>::infinity(), log2(0.0));
+  EXPECT_EQ(-std::numeric_limits<double>::infinity(), log2(-0.0));
+  EXPECT_EQ(std::numeric_limits<double>::infinity(),
+            log2(std::numeric_limits<double>::infinity()));
+}
+
+TEST(Ieee754, Log10) {
+  EXPECT_THAT(log10(std::numeric_limits<double>::quiet_NaN()), IsNaN());
+  EXPECT_THAT(log10(std::numeric_limits<double>::signaling_NaN()), IsNaN());
+  EXPECT_THAT(log10(-std::numeric_limits<double>::infinity()), IsNaN());
+  EXPECT_THAT(log10(-1.0), IsNaN());
+  EXPECT_EQ(-std::numeric_limits<double>::infinity(), log10(0.0));
+  EXPECT_EQ(-std::numeric_limits<double>::infinity(), log10(-0.0));
+  EXPECT_EQ(std::numeric_limits<double>::infinity(),
+            log10(std::numeric_limits<double>::infinity()));
+  EXPECT_EQ(3.0, log10(1000.0));
+  EXPECT_EQ(14.0, log10(100000000000000));  // log10(10 ^ 14)
+  EXPECT_EQ(3.7389561269540406, log10(5482.2158));
+  EXPECT_EQ(14.661551142893833, log10(458723662312872.125782332587));
+  EXPECT_EQ(-0.9083828622192334, log10(0.12348583358871));
+}
+
 }  // namespace ieee754
 }  // namespace base
 }  // namespace v8

test/unittests/compiler/node-test-utils.cc

@@ -2317,6 +2317,8 @@ IS_UNOP_MATCHER(NumberFloor)
 IS_UNOP_MATCHER(NumberFround)
 IS_UNOP_MATCHER(NumberLog)
 IS_UNOP_MATCHER(NumberLog1p)
+IS_UNOP_MATCHER(NumberLog2)
+IS_UNOP_MATCHER(NumberLog10)
 IS_UNOP_MATCHER(NumberRound)
 IS_UNOP_MATCHER(NumberSqrt)
 IS_UNOP_MATCHER(NumberTrunc)

test/unittests/compiler/node-test-utils.h

@@ -233,6 +233,8 @@ Matcher<Node*> IsNumberFloor(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberFround(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberLog(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberLog1p(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog2(const Matcher<Node*>& value_matcher);
+Matcher<Node*> IsNumberLog10(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberRound(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberSqrt(const Matcher<Node*>& value_matcher);
 Matcher<Node*> IsNumberTrunc(const Matcher<Node*>& value_matcher);