A64: Implement LPower and extend MathPowStub to support args in registers

src/a64/code-stubs-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2235 matching lines @@
   // jssp[1]: Base (as a tagged value).
   //
   // The (tagged) result will be returned in x0, as a heap number.
 
   Register result_tagged = x0;
   Register base_tagged = x10;
   Register exponent_tagged = x11;
   Register exponent_integer = x12;
   Register scratch1 = x14;
   Register scratch0 = x15;
+  Register saved_lr = x19;
   FPRegister result_double = d0;
-  FPRegister base_double = d1;
-  FPRegister exponent_double = d2;
+  FPRegister base_double = d0;
+  FPRegister exponent_double = d1;
+  FPRegister base_double_copy = d2;
   FPRegister scratch1_double = d6;
   FPRegister scratch0_double = d7;
 
   // A fast-path for integer exponents.
   Label exponent_is_smi, exponent_is_integer;
   // Bail out to runtime.
   Label call_runtime;
   // Allocate a heap number for the result, and return it.
   Label done;
 
-  // TODO(all): Cases other than ON_STACK are only used by Lithium, and we do
-  // not yet support them.
-  ASSERT(exponent_type_ == ON_STACK);
-
   // Unpack the inputs.
   if (exponent_type_ == ON_STACK) {
     Label base_is_smi;
     Label unpack_exponent;
 
     __ Pop(exponent_tagged, base_tagged);
 
     __ JumpIfSmi(base_tagged, &base_is_smi);
     __ JumpIfNotHeapNumber(base_tagged, &call_runtime);
     // base_tagged is a heap number, so load its double value.
     __ Ldr(base_double, FieldMemOperand(base_tagged, HeapNumber::kValueOffset));
     __ B(&unpack_exponent);
     __ Bind(&base_is_smi);
     // base_tagged is a SMI, so untag it and convert it to a double.
     __ SmiUntagToDouble(base_double, base_tagged);
 
     __ Bind(&unpack_exponent);
     //  x10   base_tagged       The tagged base (input).
     //  x11   exponent_tagged   The tagged exponent (input).
     //  d1    base_double       The base as a double.
     __ JumpIfSmi(exponent_tagged, &exponent_is_smi);
     __ JumpIfNotHeapNumber(exponent_tagged, &call_runtime);
     // exponent_tagged is a heap number, so load its double value.
     __ Ldr(exponent_double,
            FieldMemOperand(exponent_tagged, HeapNumber::kValueOffset));
-  } else {
-    UNIMPLEMENTED_M("MathPowStub types other than ON_STACK are unimplemented.");
+  } else if (exponent_type_ == TAGGED) {
+    __ JumpIfSmi(exponent_tagged, &exponent_is_smi);
+    __ Ldr(exponent_double,
+           FieldMemOperand(exponent_tagged, HeapNumber::kValueOffset));
   }
 
   // Handle double (heap number) exponents.
   if (exponent_type_ != INTEGER) {
     // Detect integer exponents stored as doubles and handle those in the
     // integer fast-path.
     __ TryConvertDoubleToInt64(exponent_integer, exponent_double,
                                scratch0_double, &exponent_is_integer);
 
     if (exponent_type_ == ON_STACK) {
@@ skipping 66 matching lines @@
       __ Fcsel(base_double, scratch1_double, base_double, vs);
 
       // Calculate the square root of base.
       __ Fsqrt(result_double, base_double);
       __ Fcmp(exponent_double, 0.0);
       __ B(ge, &done);  // Finish now for exponents of 0.5.
       // Find the inverse for exponents of -0.5.
       __ Fmov(scratch0_double, 1.0);
       __ Fdiv(result_double, scratch0_double, result_double);
       __ B(&done);
-    } else {
-      UNIMPLEMENTED_M(
-          "MathPowStub types other than ON_STACK are unimplemented.");
     }
 
-    // TODO(all): From here, call the C power function for non-ON_STACK types.
-    // ON_STACK types should not be able to reach this point.
-    ASM_UNIMPLEMENTED_BREAK(
-        "MathPowStub types other than ON_STACK are unimplemented.");
-  } else {
-    UNIMPLEMENTED_M("MathPowStub types other than ON_STACK are unimplemented.");
+    {
+      AllowExternalCallThatCantCauseGC scope(masm);
+      __ Mov(saved_lr, lr);
+      __ CallCFunction(
+          ExternalReference::power_double_double_function(masm->isolate()),
+          0, 2);
+      __ Mov(lr, saved_lr);
+      __ B(&done);
+    }
   }
 
   // Handle integer (and SMI) exponents.
   __ Bind(&exponent_is_smi);
   //  x10   base_tagged       The tagged base (input).
   //  x11   exponent_tagged   The tagged exponent (input).
   //  d1    base_double       The base as a double.
   __ SmiUntag(exponent_integer, exponent_tagged);
   __ Bind(&exponent_is_integer);
   //  x10   base_tagged       The tagged base (input).
@@ skipping 13 matching lines @@
   //    if (exponent_integer{n}) {
   //      result *= base;
   //    }
   //    base *= base;
   //    if (remaining bits in exponent_integer are all zero) {
   //      break;
   //    }
   //  }
   Label power_loop, power_loop_entry, power_loop_exit;
   __ Fmov(scratch1_double, base_double);
+  __ Fmov(base_double_copy, base_double);
   __ Fmov(result_double, 1.0);
   __ B(&power_loop_entry);
 
   __ Bind(&power_loop);
   __ Fmul(scratch1_double, scratch1_double, scratch1_double);
   __ Lsr(exponent_abs, exponent_abs, 1);
   __ Cbz(exponent_abs, &power_loop_exit);
 
   __ Bind(&power_loop_entry);
   __ Tbz(exponent_abs, 0, &power_loop);
@@ skipping 27 matching lines @@
     // Return.
     __ Bind(&done);
     __ AllocateHeapNumber(result_tagged, &call_runtime, scratch0, scratch1);
     __ Str(result_double,
         FieldMemOperand(result_tagged, HeapNumber::kValueOffset));
     ASSERT(result_tagged.is(x0));
     __ IncrementCounter(
         masm->isolate()->counters()->math_pow(), 1, scratch0, scratch1);
     __ Ret();
   } else {
-    UNIMPLEMENTED_M("MathPowStub types other than ON_STACK are unimplemented.");
+    AllowExternalCallThatCantCauseGC scope(masm);
+    __ Mov(saved_lr, lr);
+    __ Fmov(base_double, base_double_copy);
+    __ Scvtf(exponent_double, exponent_integer);
+    __ CallCFunction(
+        ExternalReference::power_double_double_function(masm->isolate()),
+        0, 2);
+    __ Mov(lr, saved_lr);
+    __ Bind(&done);
+    __ IncrementCounter(
+        masm->isolate()->counters()->math_pow(), 1, scratch0, scratch1);
+    __ Ret();
   }
 }
 
 
 void CodeStub::GenerateStubsAheadOfTime(Isolate* isolate) {
   // It is important that the following stubs are generated in this order
   // because pregenerated stubs can only call other pregenerated stubs.
   // RecordWriteStub uses StoreBufferOverflowStub, which in turn uses
   // CEntryStub.
   CEntryStub::GenerateAheadOfTime(isolate);
@@ skipping 4840 matching lines @@
     __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET);
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64