ARM64: Fix some stub-cache TODOs

src/arm64/stub-cache-arm64.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 376 matching lines @@
   if (details.type() == CONSTANT) {
     Handle<Object> constant(descriptors->GetValue(descriptor), masm->isolate());
     __ LoadObject(scratch1, constant);
     __ Cmp(value_reg, scratch1);
     __ B(ne, miss_label);
   } else if (representation.IsSmi()) {
     __ JumpIfNotSmi(value_reg, miss_label);
   } else if (representation.IsHeapObject()) {
     __ JumpIfSmi(value_reg, miss_label);
   } else if (representation.IsDouble()) {
+    UseScratchRegisterScope temps(masm);
+    Register temp_double = temps.AcquireD();
+    __ SmiUntagToDouble(temp_double, value_reg, kSpeculativeUntag);
+
     Label do_store, heap_number;
     __ AllocateHeapNumber(storage_reg, slow, scratch1, scratch2);
 
-    // TODO(jbramley): Is fp_scratch the most appropriate FP scratch register?
-    // It's only used in Fcmp, but it's not really safe to use it like this.
-    __ JumpIfNotSmi(value_reg, &heap_number);
-    __ SmiUntagToDouble(fp_scratch, value_reg);
-    __ B(&do_store);
+    __ JumpIfSmi(value_reg, &do_store);
 
-    __ Bind(&heap_number);
     __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex,
                 miss_label, DONT_DO_SMI_CHECK);
-    __ Ldr(fp_scratch, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
+    __ Ldr(temp_double, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
 
     __ Bind(&do_store);
-    __ Str(fp_scratch, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
+    __ Str(temp_double, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
   }
 
   // Stub never generated for non-global objects that require access checks.
   ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
 
   // Perform map transition for the receiver if necessary.
   if ((details.type() == FIELD) &&
       (object->map()->unused_property_fields() == 0)) {
     // The properties must be extended before we can store the value.
     // We jump to a runtime call that extends the properties array.
@@ skipping 116 matching lines @@
   // object and the number of in-object properties is not going to change.
   index -= object->map()->inobject_properties();
 
   Representation representation = lookup->representation();
   ASSERT(!representation.IsNone());
   if (representation.IsSmi()) {
     __ JumpIfNotSmi(value_reg, miss_label);
   } else if (representation.IsHeapObject()) {
     __ JumpIfSmi(value_reg, miss_label);
   } else if (representation.IsDouble()) {
+    UseScratchRegisterScope temps(masm);
+    Register temp_double = temps.AcquireD();
+
+    __ SmiUntagToDouble(temp_double, value_reg, kSpeculativeUntag);
+
     // Load the double storage.
     if (index < 0) {
       int offset = (index * kPointerSize) + object->map()->instance_size();
       __ Ldr(scratch1, FieldMemOperand(receiver_reg, offset));
     } else {
       int offset = (index * kPointerSize) + FixedArray::kHeaderSize;
       __ Ldr(scratch1,
              FieldMemOperand(receiver_reg, JSObject::kPropertiesOffset));
       __ Ldr(scratch1, FieldMemOperand(scratch1, offset));
     }
 
     // Store the value into the storage.
     Label do_store, heap_number;
-    // TODO(jbramley): Is fp_scratch the most appropriate FP scratch register?
-    // It's only used in Fcmp, but it's not really safe to use it like this.
-    __ JumpIfNotSmi(value_reg, &heap_number);
-    __ SmiUntagToDouble(fp_scratch, value_reg);
-    __ B(&do_store);
 
-    __ Bind(&heap_number);
+    __ JumpIfSmi(value_reg, &do_store);
+
     __ CheckMap(value_reg, scratch2, Heap::kHeapNumberMapRootIndex,
                 miss_label, DONT_DO_SMI_CHECK);
-    __ Ldr(fp_scratch, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
+    __ Ldr(temp_double, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
 
     __ Bind(&do_store);
-    __ Str(fp_scratch, FieldMemOperand(scratch1, HeapNumber::kValueOffset));
+    __ Str(temp_double, FieldMemOperand(scratch1, HeapNumber::kValueOffset));
 
     // Return the value (register x0).
     ASSERT(value_reg.is(x0));
     __ Ret();
     return;
   }
 
   // TODO(verwaest): Share this code as a code stub.
   SmiCheck smi_check = representation.IsTagged()
       ? INLINE_SMI_CHECK : OMIT_SMI_CHECK;
@@ skipping 417 matching lines @@
 
   __ Push(receiver());
 
   if (heap()->InNewSpace(callback->data())) {
     __ Mov(scratch3(), Operand(callback));
     __ Ldr(scratch3(), FieldMemOperand(scratch3(),
                                        ExecutableAccessorInfo::kDataOffset));
   } else {
     __ Mov(scratch3(), Operand(Handle<Object>(callback->data(), isolate())));
   }
-  // TODO(jbramley): Find another scratch register and combine the pushes
-  // together. Can we use scratch1() here?
   __ LoadRoot(scratch4(), Heap::kUndefinedValueRootIndex);
-  __ Push(scratch3(), scratch4());
-  __ Mov(scratch3(), ExternalReference::isolate_address(isolate()));
-  __ Push(scratch4(), scratch3(), reg, name());
+  __ Mov(scratch2(), Operand(ExternalReference::isolate_address(isolate())));
+  __ Push(scratch3(), scratch4(), scratch4(), scratch2(), reg, name());
 
   Register args_addr = scratch2();
   __ Add(args_addr, __ StackPointer(), kPointerSize);
 
   // Stack at this point:
   //              sp[40] callback data
   //              sp[32] undefined
   //              sp[24] undefined
   //              sp[16] isolate
   // args_addr -> sp[8]  reg
@@ skipping 462 matching lines @@
 
   // Miss case, call the runtime.
   __ Bind(&miss);
   TailCallBuiltin(masm, Builtins::kKeyedLoadIC_Miss);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64