A64: Improve constraints for StoreNamedField

src/a64/lithium-a64.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 2213 matching lines @@
   ASSERT(instr->object()->representation().IsTagged());
   ASSERT(instr->key()->representation().IsTagged());
   ASSERT(instr->value()->representation().IsTagged());
 
   return MarkAsCall(
       new(zone()) LStoreKeyedGeneric(context, object, key, value), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoStoreNamedField(HStoreNamedField* instr) {
-  // TODO(jbramley): Optimize register usage in this instruction. For now, it
-  // allocates everything that it might need because it keeps changing in the
-  // merge and keeping it valid is time-consuming.
-
   // TODO(jbramley): It might be beneficial to allow value to be a constant in
   // some cases. x64 makes use of this with FLAG_track_fields, for example.
 
   LOperand* object = UseRegister(instr->object());

[ulan, 2014/03/07 15:16:26]

This is difficult to understand and to keep in sync with codegen. I hope it pays
off with performance improvement.

To make reading a little bit easier, could you please rearrange the conditions
to mirror the structure of codegen?

Along these lines:

if (instr->access().IsExternalMemory() ||
instr->field_representation().IsDouble()) {
 ...
} else if (instr->NeedsWriteBarrierForMap() || instr->NeedsWriteBarrier()) {
 ...
} else {
 ...
}

-  LOperand* value = UseRegisterAndClobber(instr->value());
-  LOperand* temp0 = TempRegister();
-  LOperand* temp1 = TempRegister();
+  LOperand* value;
+  LOperand* temp0 = NULL;
+  LOperand* temp1 = NULL;
+  if (instr->NeedsWriteBarrier()) {
+    value = UseRegisterAndClobber(instr->value());
+    temp0 = TempRegister();
+    temp1 = TempRegister();
+  } else {
+    value = UseRegister(instr->value());
+    if (!(instr->access().IsExternalMemory() ||
+          instr->field_representation().IsDouble())) {
+      temp0 = TempRegister();
+      if (instr->NeedsWriteBarrierForMap()) {
+        temp1 = TempRegister();
+      }
+    }
+  }
 
   LStoreNamedField* result =
       new(zone()) LStoreNamedField(object, value, temp0, temp1);
   if (instr->field_representation().IsHeapObject() &&
       !instr->value()->type().IsHeapObject()) {
     return AssignEnvironment(result);
   }
   return result;
 }
 
@@ skipping 297 matching lines @@
 
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegister(instr->function());
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal