X64: Abstract indexing by a smi to the macro assembler.

src/x64/macro-assembler-x64.h

 // Copyright 2009 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 23 matching lines @@
 namespace internal {
 
 // Default scratch register used by MacroAssembler (and other code that needs
 // a spare register). The register isn't callee save, and not used by the
 // function calling convention.
 static const Register kScratchRegister = r10;
 
 // Forward declaration.
 class JumpTarget;
 
+struct SmiIndex {

[William Hesse, 2009/09/15 10:12:09]

Are we allowed to create constructors for structs, according to the C++ style
guide?

[Lasse Reichstein, 2009/09/15 10:39:08]

Yes (I had to check to be sure).

+  SmiIndex(Register index_register, ScaleFactor scale)
+      : reg(index_register),
+        scale(scale) {}
+  Register reg;
+  ScaleFactor scale;
+};
 
 // MacroAssembler implements a collection of frequently used macros.
 class MacroAssembler: public Assembler {
  public:
   MacroAssembler(void* buffer, int size);
 
   void LoadRoot(Register destination, Heap::RootListIndex index);
   void CompareRoot(Register with, Heap::RootListIndex index);
   void PushRoot(Heap::RootListIndex index);
 
@@ skipping 180 matching lines @@
                       Label* on_not_smi_result);
 
   // Subtract an integer constant from a tagged smi, giving a tagged smi as
   // result, or jumping to a label if the result cannot be represented by a smi.
   // If the label is NULL, no testing on the result is done.
   void SmiSubConstant(Register dst,
                       Register src,
                       int32_t constant,
                       Label* on_not_smi_result);
 
-  // Negating a smi can give a negative zero or too larget positive value.
+  // Negating a smi can give a negative zero or too large positive value.
   void SmiNeg(Register dst,
               Register src,
               Label* on_not_smi_result);
 
   // Adds smi values and return the result as a smi.
   // If dst is src1, then src1 will be destroyed, even if
   // the operation is unsuccessful.
   void SmiAdd(Register dst,
               Register src1,
               Register src2,
               Label* on_not_smi_result);
+
   // Subtracts smi values and return the result as a smi.
   // If dst is src1, then src1 will be destroyed, even if
   // the operation is unsuccessful.
   void SmiSub(Register dst,
               Register src1,
               Register src2,
               Label* on_not_smi_result);
+
   // Multiplies smi values and return the result as a smi,
   // if possible.
   // If dst is src1, then src1 will be destroyed, even if
   // the operation is unsuccessful.
   void SmiMul(Register dst,
               Register src1,
               Register src2,
               Label* on_not_smi_result);
 
   // Divides one smi by another and returns the quotient.
@@ skipping 55 matching lines @@
 
   // Specialized operations
 
   // Select the non-smi register of two registers where exactly one is a
   // smi. If neither are smis, jump to the failure label.
   void SelectNonSmi(Register dst,
                     Register src1,
                     Register src2,
                     Label* on_not_smis);
 
+  // Converts, if necessary, a smi to a combination of number and
+  // multiplier to be used as a scaled index.
+  // The src register contains a *positive* smi value. The shift is the
+  // power of two to multiply the index value by (e.g.
+  // to index by smi-value * kPointerSize, pass the smi and kPointerSizeLog2).
+  // The returned index register may be either src or dst, depending
+  // on what is most efficient. If src and dst are different registers,
+  // src is always unchanged.

[William Hesse, 2009/09/15 10:12:09]

Don't those two sentences contradict each other?  How could the returned
register be src, if src is not dst, and src must be unchanged?

[Lasse Reichstein, 2009/09/15 10:39:08]

It can happen if an unchanged src combined with a ScaleFactor is sufficient.
Then dst is not written, and src i returned unmodified together with (typically)
times_4.
(However, after handling zero-extension, the returned register will, in
practice, always be dst).

+  SmiIndex SmiToIndex(Register dst, Register src, int shift);
+
+  // Converts a positive smi to a negative index.
+  SmiIndex SmiToNegativeIndex(Register dst, Register src, int shift);
+
   // ---------------------------------------------------------------------------
   // Macro instructions
 
   // Expression support
   void Set(Register dst, int64_t x);
   void Set(const Operand& dst, int64_t x);
 
   // Handle support
   bool IsUnsafeSmi(Smi* value);
   bool IsUnsafeSmi(Handle<Object> value) {
@@ skipping 297 matching lines @@
   }                                                                       \
   masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_MACRO_ASSEMBLER_X64_H_