HStoreNamedField for Smis optimized for x64

src/x64/lithium-codegen-x64.cc

 // Copyright 2013 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 3928 matching lines @@
     }
     return;
   }
 
   Register object = ToRegister(instr->object());
   Handle<Map> transition = instr->transition();
 
   if (FLAG_track_fields && representation.IsSmi()) {
     if (instr->value()->IsConstantOperand()) {
       LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
-      if (!IsSmiConstant(operand_value)) {
+      if (!IsInteger32Constant(operand_value) &&
+          !IsSmiConstant(operand_value)) {
         DeoptimizeIf(no_condition, instr->environment());
       }
     }
   } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
     if (instr->value()->IsConstantOperand()) {
       LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
       if (IsInteger32Constant(operand_value)) {
         DeoptimizeIf(no_condition, instr->environment());
       }
     } else {
@@ skipping 34 matching lines @@
   SmiCheck check_needed =
       instr->hydrogen()->value()->IsHeapObject()
           ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
 
   Register write_register = object;
   if (!access.IsInobject()) {
     write_register = ToRegister(instr->temp());
     __ movq(write_register, FieldOperand(object, JSObject::kPropertiesOffset));
   }
 
+  bool kScratchRegisterContainsZero = false;
+  if (representation.IsSmi()) {
+    if (!instr->hydrogen()->can_omit_smi_tag_store()) {
+      // Clear the smi tag as we are not sure that it contains the right value.
+      __ xorl(kScratchRegister, kScratchRegister);
+      kScratchRegisterContainsZero = true;
+      __ movl(FieldOperand(write_register, offset), kScratchRegister);

[Toon Verwaest, 2013/12/09 15:51:10]

What about just shifting up the value and storing the entire 64 bits if you need
to clear? Seems like that should be at least shorter in number of instruction
bytes.

Especially if the value is constant. In that case you can just load the entire
constant in a register and write that in 1 go. You shouldn't need
kScratchRegisterContainsZero.

[Igor Sheludko, 2013/12/10 09:13:08]

Done.

+    }
+    // Deal with the upper part of the smi containing the value.
+    offset += kPointerSize / 2;
+    representation = Representation::Integer32();
+  }
+
   if (instr->value()->IsConstantOperand()) {
     LConstantOperand* operand_value = LConstantOperand::cast(instr->value());
     if (operand_value->IsRegister()) {
       Register value = ToRegister(operand_value);
       __ Store(FieldOperand(write_register, offset), value, representation);
     } else if (representation.IsInteger32()) {
       int32_t value = ToInteger32(operand_value);
       ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
-      __ movl(FieldOperand(write_register, offset), Immediate(value));
+      if ((value == 0) && kScratchRegisterContainsZero) {
+        __ movl(FieldOperand(write_register, offset), kScratchRegister);
+      } else {
+        __ movl(FieldOperand(write_register, offset), Immediate(value));
+      }
     } else {
       Handle<Object> handle_value = ToHandle(operand_value);
       ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
       __ Move(FieldOperand(write_register, offset), handle_value);
     }
   } else {
     Register value = ToRegister(instr->value());
     __ Store(FieldOperand(write_register, offset), value, representation);
   }
 
@@ skipping 1559 matching lines @@
                                FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64