A64: Implement and use FillFields

src/a64/macro-assembler-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 2436 matching lines @@
 
   Bind(&loop);
   Sub(length, length, 1);
   Ldrb(scratch, MemOperand(src, 1, PostIndex));
   Strb(scratch, MemOperand(dst, 1, PostIndex));
   Cbnz(length, &loop);
   Bind(&done);
 }
 
 
-void MacroAssembler::InitializeFieldsWithFiller(Register start_offset,
-                                                Register end_offset,
-                                                Register filler) {
-  Label loop, entry;
+void MacroAssembler::FillFields(Register dst,
+                                Register field_count,
+                                Register filler) {
+  ASSERT(!dst.Is(csp));
+  UseScratchRegisterScope temps(this);
+  Register field_ptr = temps.AcquireX();
+  Register counter = temps.AcquireX();
+  Label done;
+
+  // Decrement count. If the result < zero, count was zero, and there's nothing
+  // to do. If count was one, flags are set to fail the gt condition at the end
+  // of the pairs loop.
+  Subs(counter, field_count, 1);
+  B(lt, &done);
+
+  // There's at least one field to fill, so do this unconditionally.
+  Str(filler, MemOperand(dst, kPointerSize, PostIndex));
+
+  // If the bottom bit of counter is set, there are an even number of fields to
+  // fill, so pull the start pointer back by one field, allowing the pairs loop
+  // to overwrite the field that was stored above.
+  And(field_ptr, counter, 1);
+  Sub(field_ptr, dst, Operand(field_ptr, LSL, kPointerSizeLog2));

[ulan, 2014/03/12 12:17:26]

I am convinced that this implementation is correct.

Any reason why you didn't choose the algorithm that is used in other places? 

In pseudocode:

counter = field_count - 2;
while (counter >= 0) {
  store pair of fillers;
  counter -= 2;
}
if (counter & 1) {
  store one remaining filler;
}

+
+  // Store filler to memory in pairs.
+  Label entry, loop;
   B(&entry);
   Bind(&loop);
-  // TODO(all): consider using stp here.
-  Str(filler, MemOperand(start_offset, kPointerSize, PostIndex));
+  Stp(filler, filler, MemOperand(field_ptr, 2 * kPointerSize, PostIndex));
+  Subs(counter, counter, 2);
   Bind(&entry);
-  Cmp(start_offset, end_offset);
-  B(lt, &loop);
+  B(gt, &loop);
+
+  Bind(&done);
 }
 
 
 void MacroAssembler::JumpIfEitherIsNotSequentialAsciiStrings(
     Register first,
     Register second,
     Register scratch1,
     Register scratch2,
     Label* failure,
     SmiCheckType smi_check) {
@@ skipping 2630 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64