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

src/x64/macro-assembler-x64.cc

 // 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 1074 matching lines @@
   // If src1 is a smi, then scratch register all 1s, else it is all 0s.
   movq(dst, src1);
   xor_(dst, src2);
   and_(dst, kScratchRegister);
   // If src1 is a smi, dst holds src1 ^ src2, else it is zero.
   xor_(dst, src1);
   // If src1 is a smi, dst is src2, else it is src1, i.e., a non-smi.
 }
 
 
+SmiIndex MacroAssembler::SmiToIndex(Register dst, Register src, int shift) {
+  ASSERT(is_uint6(shift));
+  if (shift == 0) {  // times_1.
+    SmiToInteger32(dst, src);
+    return SmiIndex(dst, times_1);
+  }
+  if (shift <= 4) {  // 2 - 16 times multiplier.
+    return SmiIndex(src, static_cast<ScaleFactor>(shift - kSmiTagSize));

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

How are we making sure that src is zero-extended here?  Won't this cause errors?
Also, shouldn't we check 0 <= shift-kSmiTagSize < 4 ?

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

We should make sure. I'll add a movel(dst, src).

This code assumes the value of kSmiTagSize is 1. If that changes, all the
abstraced smi operations must be checked.

+  }
+  // Shift by shift-kSmiTagSize.
+  if (!dst.is(src)) {
+    movl(dst, src);
+  }
+  shl(dst, Immediate(shift - kSmiTagSize));
+  return SmiIndex(dst, times_1);
+}
+
+
+SmiIndex MacroAssembler::SmiToNegativeIndex(Register dst,
+                                            Register src,
+                                            int shift) {
+  // Register src holds a positive smi.
+  ASSERT(is_uint6(shift));
+  if (shift == 0) {  // times_1.
+    SmiToInteger32(dst, src);
+    neg(dst);
+    return SmiIndex(dst, times_1);
+  }
+  if (shift <= 4) {  // 2 - 16 times multiplier is handled using ScaleFactor.
+    if (!dst.is(src)) {
+      movl(dst, src);
+    }
+    neg(dst);
+    return SmiIndex(dst, static_cast<ScaleFactor>(shift - kSmiTagSize));
+  }
+  // Shift by shift-kSmiTagSize.
+  if (!dst.is(src)) {
+    movl(dst, src);
+  }
+  neg(dst);
+  shl(dst, Immediate(shift - kSmiTagSize));
+  return SmiIndex(dst, times_1);
+}
+
+
 
 bool MacroAssembler::IsUnsafeSmi(Smi* value) {
   return false;
 }
 
 void MacroAssembler::LoadUnsafeSmi(Register dst, Smi* source) {
   UNIMPLEMENTED();
 }
 
 
@@ skipping 995 matching lines @@
   // Indicate that code has changed.
   CPU::FlushICache(address_, size_);
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 
 } }  // namespace v8::internal