A64: Handle a few TODOs.

src/a64/builtins-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 167 matching lines @@
     __ Assert(eq, kUnexpectedStringFunction);
   }
 
   // Load the first arguments in x0 and get rid of the rest.
   Label no_arguments;
   __ Cbz(argc, &no_arguments);
   // First args = sp[(argc - 1) * 8].
   __ Sub(argc, argc, 1);
   __ Claim(argc, kXRegSizeInBytes);
   // jssp now point to args[0], load and drop args[0] + receiver.
-  // TODO(jbramley): Consider adding ClaimAndPoke.
-  __ Ldr(argc, MemOperand(jssp, 2 * kPointerSize, PostIndex));
+  Register arg = argc;
+  __ Ldr(arg, MemOperand(jssp, 2 * kPointerSize, PostIndex));
+  argc = NoReg;
 
   Register argument = x2;
   Label not_cached, argument_is_string;
-  __ LookupNumberStringCache(argc,       // Input.
+  __ LookupNumberStringCache(arg,        // Input.
                              argument,   // Result.
                              x10,        // Scratch.
                              x11,        // Scratch.
                              x12,        // Scratch.
                              &not_cached);
   __ IncrementCounter(counters->string_ctor_cached_number(), 1, x10, x11);
   __ Bind(&argument_is_string);
 
   // ----------- S t a t e -------------
   //  -- x2     : argument converted to string
@@ skipping 27 matching lines @@
 
   // Ensure the object is fully initialized.
   STATIC_ASSERT(JSValue::kSize == (4 * kPointerSize));
 
   __ Ret();
 
   // The argument was not found in the number to string cache. Check
   // if it's a string already before calling the conversion builtin.
   Label convert_argument;
   __ Bind(&not_cached);
-  __ JumpIfSmi(argc, &convert_argument);
+  __ JumpIfSmi(arg, &convert_argument);
 
   // Is it a String?
   __ Ldr(x10, FieldMemOperand(x0, HeapObject::kMapOffset));
   __ Ldrb(x11, FieldMemOperand(x10, Map::kInstanceTypeOffset));
   __ Tbnz(x11, MaskToBit(kIsNotStringMask), &convert_argument);
-  __ Mov(argument, argc);
+  __ Mov(argument, arg);
   __ IncrementCounter(counters->string_ctor_string_value(), 1, x10, x11);
   __ B(&argument_is_string);
 
   // Invoke the conversion builtin and put the result into x2.
   __ Bind(&convert_argument);
   __ Push(function);  // Preserve the function.
   __ IncrementCounter(counters->string_ctor_conversions(), 1, x10, x11);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
-    __ Push(argc);
+    __ Push(arg);
     __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
   }
   __ Pop(function);
   __ Mov(argument, x0);
   __ B(&argument_is_string);
 
   // Load the empty string into x2, remove the receiver from the
   // stack, and jump back to the case where the argument is a string.
   __ Bind(&no_arguments);
   __ LoadRoot(argument, Heap::kempty_stringRootIndex);
@@ skipping 434 matching lines @@
     __ Mov(x22, x19);
     __ Mov(x23, x19);
     __ Mov(x24, x19);
     __ Mov(x25, x19);
     // Don't initialize the reserved registers.
     // x26 : root register (root).
     // x27 : context pointer (cp).
     // x28 : JS stack pointer (jssp).
     // x29 : frame pointer (fp).
 
-    // TODO(alexandre): Revisit the MAsm function invocation mechanisms.
-    // Currently there is a mix of statically and dynamically allocated
-    // registers.
     __ Mov(x0, argc);
     if (is_construct) {
       // No type feedback cell is available.
       Handle<Object> undefined_sentinel(
           masm->isolate()->heap()->undefined_value(), masm->isolate());
       __ Mov(x2, Operand(undefined_sentinel));
 
       CallConstructStub stub(NO_CALL_FUNCTION_FLAGS);
       __ CallStub(&stub);
     } else {
@@ skipping 745 matching lines @@
   __ Bind(&dont_adapt_arguments);
   __ Jump(x3);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM