Implement a code stub for floating point modulo operation

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 1309 matching lines @@
                                       Label* gc_required,
                                       Label* miss,
                                       Token::Value op,
                                       OverwriteMode mode) {
   ASM_LOCATION("BinaryOpStub_GenerateFPOperation");
 
   Register result = x0;
   FPRegister result_d = d0;
   Register right = x0;
   Register left = x1;
-  Register heap_result = x3;
+  Register heap_result = x19;
 
   ASSERT(smi_operands || (not_numbers != NULL));
   if (smi_operands) {
     __ AssertSmi(left);
     __ AssertSmi(right);
   }
   if (left_type == BinaryOpIC::SMI) {
     __ JumpIfNotSmi(left, miss);
   }
   if (right_type == BinaryOpIC::SMI) {
     __ JumpIfNotSmi(right, miss);
   }
 
   Register heap_number_map = x2;
   __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
 
   switch (op) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD: {
-      FPRegister right_d = d0;
-      FPRegister left_d = d1;
+      FPRegister left_d = d0;
+      FPRegister right_d = d1;
       Label do_operation;
 
       __ SmiUntagToDouble(left_d, left, kSpeculativeUntag);
       __ SmiUntagToDouble(right_d, right, kSpeculativeUntag);
 
       if (!smi_operands) {
         if (left_type != BinaryOpIC::SMI) {
           Label left_done;
           Label* left_not_heap =
               (left_type == BinaryOpIC::NUMBER) ? miss : not_numbers;
@@ skipping 11 matching lines @@
           __ JumpIfSmi(right, &do_operation);
 
           // Right not smi: load if heap number.
           __ JumpIfNotHeapNumber(right, right_not_heap, heap_number_map);
           __ Ldr(right_d, FieldMemOperand(right, HeapNumber::kValueOffset));
         }
       }
 
       // Left and right are doubles in left_d and right_d. Calculate the result.
       __ Bind(&do_operation);
+
+      BinaryOpStub_GenerateHeapResultAllocation(
+          masm, heap_result, heap_number_map, x10, x11, gc_required, mode);
+
       switch (op) {
         case Token::ADD: __ Fadd(result_d, left_d, right_d); break;
         case Token::SUB: __ Fsub(result_d, left_d, right_d); break;
         case Token::MUL: __ Fmul(result_d, left_d, right_d); break;
         case Token::DIV: __ Fdiv(result_d, left_d, right_d); break;
-        case Token::MOD:
-          ASM_UNIMPLEMENTED("Implement HeapNumber modulo");
-          __ B(miss);
+        case Token::MOD: {
+          Register saved_lr = x20;
+          __ Mov(saved_lr, lr);
+          AllowExternalCallThatCantCauseGC scope(masm);
+          __ CallCFunction(
+              ExternalReference::double_fp_operation(op, masm->isolate()),
+              0, 2);
+          __ Mov(lr, saved_lr);
           break;
+        }
         default: UNREACHABLE();
       }
 
-      BinaryOpStub_GenerateHeapResultAllocation(
-          masm, heap_result, heap_number_map, x10, x11, gc_required, mode);
-
       __ Str(result_d, FieldMemOperand(heap_result, HeapNumber::kValueOffset));
       __ Mov(result, heap_result);
       __ Ret();
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND:
     case Token::SAR:
@@ skipping 5653 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64