Introduce StackArgumentsAccessor class for X64

src/x64/macro-assembler-x64.h

 // 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 1500 matching lines @@
 inline Operand StackSpaceOperand(int index) {
 #ifdef _WIN64
   const int kShaddowSpace = 4;
   return Operand(rsp, (index + kShaddowSpace) * kPointerSize);
 #else
   return Operand(rsp, index * kPointerSize);
 #endif
 }
 
 
+// Assumes the return address size equals an argument size.
+// Considers receiver as argument 0.
+inline Operand StackOperandForArgument(int32_t disp) {
+  // Adjusts the disp with kPCOnStackSize - kPointerSize.
+  return Operand(rsp, disp + kPCOnStackSize - kPointerSize);

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

Does it make sense to use an index rather than displacement? It would simplify
the usage sites. i.e.:

return Operand(rsp, (index * kPointerSize) + kPCOnStackSize - kPointerSize +
extra_disp);

extra_disp can be a default parameter with value 0

[haitao.feng, 2013/07/31 09:25:20]

I have thought about this. I did not use it as index actually is counted from
stack pointer, not from argument0. The reader might think
StackOperandForArgument(index) is accessing the ith argument.

How about defining this function as:
inline Operand StackOperandForReversedArgument(int index) {
  return Operand(rsp, (index * kPointerSize) + kPCOnStackSize);
}
Index is counted from the argument n (rsp + kPCOnStackSize), instead of argument
0 or rsp. If we want it from argument 0, we might need two arguments (one index,
one argc). 

inline Operand StackOperandForReceiver(int argc) {
  return StackOperandForReversedArgument(argc);
}

If you are OK with this, I will start updating the codes to use this interface. 

+}
+
+
+// Assumes the return address size equals an argument size.
+// Considers receiver as argument 0.
+inline Operand StackOperandForArgument(Register index,
+                                       ScaleFactor scale,
+                                       int32_t disp) {

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

Same here (index rather than displacement)?

+  // Adjusts the disp with kPCOnStackSize - kPointerSize.
+  return Operand(rsp, index, scale, disp + kPCOnStackSize - kPointerSize);
+}
+
 
 #ifdef GENERATED_CODE_COVERAGE
 extern void LogGeneratedCodeCoverage(const char* file_line);
 #define CODE_COVERAGE_STRINGIFY(x) #x
 #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) {                                                  \
     Address x64_coverage_function = FUNCTION_ADDR(LogGeneratedCodeCoverage); \
     masm->pushfq();                                                          \
     masm->Pushad();                                                          \
     masm->push(Immediate(reinterpret_cast<int>(&__FILE_LINE__)));            \
     masm->Call(x64_coverage_function, RelocInfo::EXTERNAL_REFERENCE);        \
     masm->pop(rax);                                                          \
     masm->Popad();                                                           \
     masm->popfq();                                                           \
   }                                                                          \
   masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_MACRO_ASSEMBLER_X64_H_