HStoreKeyed for Smis optimized for x64 + related redundant moves of elements removed

src/x64/lithium-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 490 matching lines @@
              new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER,
                               LUnallocated::USED_AT_START));
 }
 
 
 LOperand* LChunkBuilder::UseTempRegister(HValue* value) {
   return Use(value, new(zone()) LUnallocated(LUnallocated::WRITABLE_REGISTER));
 }
 
 
+LOperand* LChunkBuilder::UseTempRegisterOrConstant(HValue* value) {
+  return value->IsConstant()
+      ? chunk_->DefineConstantOperand(HConstant::cast(value))
+      : UseTempRegister(value);
+}
+
+
 LOperand* LChunkBuilder::Use(HValue* value) {
   return Use(value, new(zone()) LUnallocated(LUnallocated::NONE));
 }
 
 
 LOperand* LChunkBuilder::UseAtStart(HValue* value) {
   return Use(value, new(zone()) LUnallocated(LUnallocated::NONE,
                                      LUnallocated::USED_AT_START));
 }
 
@@ skipping 1650 matching lines @@
 LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
 
   if (!instr->is_external()) {
     ASSERT(instr->elements()->representation().IsTagged());
     bool needs_write_barrier = instr->NeedsWriteBarrier();
     LOperand* object = NULL;
     LOperand* key = NULL;
     LOperand* val = NULL;
 
-    if (instr->value()->representation().IsDouble()) {
+    Representation value_representation = instr->value()->representation();
+    if (value_representation.IsDouble()) {
       object = UseRegisterAtStart(instr->elements());
       val = UseTempRegister(instr->value());
       key = UseRegisterOrConstantAtStart(instr->key());
     } else {
-      ASSERT(instr->value()->representation().IsSmiOrTagged());
-      object = UseTempRegister(instr->elements());
+      ASSERT(value_representation.IsSmiOrTagged() ||
+             value_representation.IsInteger32());
       if (needs_write_barrier) {
+        object = UseTempRegister(instr->elements());
         val = UseTempRegister(instr->value());
         key = UseTempRegister(instr->key());
       } else {
-        val = UseRegisterOrConstantAtStart(instr->value());
+        object = UseRegisterAtStart(instr->elements());

[Toon Verwaest, 2013/12/17 13:53:04]

None of the variables here should probably be "AtStart". AtStart means:
   // Lifetime of operand inside the instruction.
   enum Lifetime {
     // USED_AT_START operand is guaranteed to be live only at
     // instruction start. Register allocator is free to assign the same
register
     // to some other operand used inside instruction (i.e. temporary or
     // output).
     USED_AT_START,

Given that you also use temps, this may make the register allocator give you the
same register for both the "AtStart" registers and the temp registers.

[Igor Sheludko, 2013/12/18 10:01:33]

We discussed the "AtStart" issue and decided that since this comment concerns
all the other places where we use "AtStart" methods there should be a different
"cleanup" CL fixing that.

+        if (value_representation.IsInteger32() &&
+            !instr->store_to_initialized_element()) {
+          // In this case we will need a writable register to convert
+          // int32 to smi if the value is in register.
+          val = UseTempRegisterOrConstant(instr->value());
+        } else {
+          val = UseRegisterOrConstantAtStart(instr->value());
+        }
         key = UseRegisterOrConstantAtStart(instr->key());
       }
     }
 
     return new(zone()) LStoreKeyed(object, key, val);
   }
 
   ASSERT(
       (instr->value()->representation().IsInteger32() &&
        (elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ skipping 397 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   return DefineSameAsFirst(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64