Introduce StackArgumentsAccessor class for X64

src/x64/ic-x64.cc

 // Copyright 2012 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 887 matching lines @@
   // rsp[0]              : return address
   // rsp[8]              : argument argc
   // rsp[16]             : argument argc - 1
   // ...
   // rsp[argc * 8]       : argument 1
   // rsp[(argc + 1) * 8] : argument 0 = receiver
   // -----------------------------------
   Label miss;
 
   // Get the receiver of the function from the stack.
-  __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));
+  __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));
 
   GenerateNameDictionaryReceiverCheck(masm, rdx, rax, rbx, &miss);
 
   // rax: elements
   // Search the dictionary placing the result in rdi.
   GenerateDictionaryLoad(masm, &miss, rax, rcx, rbx, rdi, rdi);
 
   GenerateFunctionTailCall(masm, argc, &miss);
 
   __ bind(&miss);
@@ skipping 15 matching lines @@
   // -----------------------------------
 
   Counters* counters = masm->isolate()->counters();
   if (id == IC::kCallIC_Miss) {
     __ IncrementCounter(counters->call_miss(), 1);
   } else {
     __ IncrementCounter(counters->keyed_call_miss(), 1);
   }
 
   // Get the receiver of the function from the stack; 1 ~ return address.
-  __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));
+  __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));
 
   // Enter an internal frame.
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
 
     // Push the receiver and the name of the function.
     __ push(rdx);
     __ push(rcx);
 
     // Call the entry.
     CEntryStub stub(1);
     __ Set(rax, 2);
     __ LoadAddress(rbx, ExternalReference(IC_Utility(id), masm->isolate()));
     __ CallStub(&stub);
 
     // Move result to rdi and exit the internal frame.
     __ movq(rdi, rax);
   }
 
   // Check if the receiver is a global object of some sort.
   // This can happen only for regular CallIC but not KeyedCallIC.
   if (id == IC::kCallIC_Miss) {
     Label invoke, global;
-    __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));  // receiver
+    // Get the receiver of the function from the stack; 1 ~ return address.

[danno, 2013/07/31 07:48:37]

I don't understand the comment, what do you mean by "1 ~ return address"? Just
use StackOperandForReceiver as described below, then I don't think you need a
comment at all.

+    __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));
     __ JumpIfSmi(rdx, &invoke);
     __ CmpObjectType(rdx, JS_GLOBAL_OBJECT_TYPE, rcx);
     __ j(equal, &global);
     __ CmpInstanceType(rcx, JS_BUILTINS_OBJECT_TYPE);
     __ j(not_equal, &invoke);
 
     // Patch the receiver on the stack.
     __ bind(&global);
     __ movq(rdx, FieldOperand(rdx, GlobalObject::kGlobalReceiverOffset));
-    __ movq(Operand(rsp, (argc + 1) * kPointerSize), rdx);
+    __ movq(StackOperandForArgument((argc + 1) * kPointerSize), rdx);
     __ bind(&invoke);
   }
 
   // Invoke the function.
   CallKind call_kind = CallICBase::Contextual::decode(extra_state)
       ? CALL_AS_FUNCTION
       : CALL_AS_METHOD;
   ParameterCount actual(argc);
   __ InvokeFunction(rdi,
                     actual,
@@ skipping 10 matching lines @@
   // rcx                 : function name
   // rsp[0]              : return address
   // rsp[8]              : argument argc
   // rsp[16]             : argument argc - 1
   // ...
   // rsp[argc * 8]       : argument 1
   // rsp[(argc + 1) * 8] : argument 0 = receiver
   // -----------------------------------
 
   // Get the receiver of the function from the stack; 1 ~ return address.
-  __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));
+  __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));
   GenerateMonomorphicCacheProbe(masm, argc, Code::CALL_IC, extra_ic_state);
   GenerateMiss(masm, argc, extra_ic_state);
 }
 
 
 void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {
   // ----------- S t a t e -------------
   // rcx                 : function name
   // rsp[0]              : return address
   // rsp[8]              : argument argc
   // rsp[16]             : argument argc - 1
   // ...
   // rsp[argc * 8]       : argument 1
   // rsp[(argc + 1) * 8] : argument 0 = receiver
   // -----------------------------------
 
   // Get the receiver of the function from the stack; 1 ~ return address.
-  __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));
+  __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));
 
   Label do_call, slow_call, slow_load;
   Label check_number_dictionary, check_name, lookup_monomorphic_cache;
   Label index_smi, index_name;
 
   // Check that the key is a smi.
   __ JumpIfNotSmi(rcx, &check_name);
 
   __ bind(&index_smi);
   // Now the key is known to be a smi. This place is also jumped to from below
@@ skipping 257 matching lines @@
   // ----------- S t a t e -------------
   // rcx                 : function name
   // rsp[0]              : return address
   // rsp[8]              : argument argc
   // rsp[16]             : argument argc - 1
   // ...
   // rsp[argc * 8]       : argument 1
   // rsp[(argc + 1) * 8] : argument 0 = receiver
   // -----------------------------------
   Label slow, notin;
-  __ movq(rdx, Operand(rsp, (argc + 1) * kPointerSize));
+  __ movq(rdx, StackOperandForArgument((argc + 1) * kPointerSize));

[danno, 2013/07/31 07:48:37]

Just to make it even prettier/more readible, how about introducing a
StackOperandForReceiver where you just pass argc, and it calls
StackOperandForArgument with (argc+1)?

   Operand mapped_location = GenerateMappedArgumentsLookup(
       masm, rdx, rcx, rbx, rax, r8, &notin, &slow);
   __ movq(rdi, mapped_location);
   GenerateFunctionTailCall(masm, argc, &slow);
   __ bind(&notin);
   // The unmapped lookup expects that the parameter map is in rbx.
   Operand unmapped_location =
       GenerateUnmappedArgumentsLookup(masm, rcx, rbx, rax, &slow);
   __ CompareRoot(unmapped_location, Heap::kTheHoleValueRootIndex);
   __ j(equal, &slow);
@@ skipping 361 matching lines @@
   Condition cc = (check == ENABLE_INLINED_SMI_CHECK)
       ? (*jmp_address == Assembler::kJncShortOpcode ? not_zero : zero)
       : (*jmp_address == Assembler::kJnzShortOpcode ? not_carry : carry);
   *jmp_address = static_cast<byte>(Assembler::kJccShortPrefix | cc);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64