4673 // base:   Address of a buffer to be zeroed, 8 bytes aligned.

  4674 // cnt:    Count in 8-byte unit.

  4675 void MacroAssembler::zero_words(Register base, Register cnt)

  4676 {

  4677   fill_words(base, cnt, zr);

  4678 }

  4679 

  4680 // base:   Address of a buffer to be filled, 8 bytes aligned.

  4681 // cnt:    Count in 8-byte unit.

  4682 // value:  Value to be filled with.

  4683 // base will point to the end of the buffer after filling.

  4684 void MacroAssembler::fill_words(Register base, Register cnt, Register value)

  4685 {

  4686 //  Algorithm:

  4687 //

  4688 //    scratch1 = cnt & 7;

  4689 //    cnt -= scratch1;

  4690 //    p += scratch1;

  4691 //    switch (scratch1) {

  4692 //      do {

  4693 //        cnt -= 8;

  4694 //          p[-8] = v;

  4695 //        case 7:

  4696 //          p[-7] = v;

  4697 //        case 6:

  4698 //          p[-6] = v;

  4699 //          // ...

  4700 //        case 1:

  4701 //          p[-1] = v;

  4702 //        case 0:

  4703 //          p += 8;

  4704 //      } while (cnt);

  4705 //    }

  4706 

  4707   assert_different_registers(base, cnt, value, rscratch1, rscratch2);

  4708 

  4709   Label entry, loop;

  4710   const int unroll = 8; // Number of str instructions we'll unroll

  4711 

  4712   andr(rscratch1, cnt, unroll - 1);  // tmp1 = cnt % unroll

  4713   cbz(rscratch1, entry);

  4714   sub(cnt, cnt, rscratch1);          // cnt -= tmp1

  4715   // base always points to the end of the region we're about to fill

  4716   add(base, base, rscratch1, Assembler::LSL, 3);

  4717   adr(rscratch2, entry);

  4718   sub(rscratch2, rscratch2, rscratch1, Assembler::LSL, 2);

  4719   br(rscratch2);

  4720   bind(loop);

  4721   add(base, base, unroll * 8);

  4722   sub(cnt, cnt, unroll);

  4723   for (int i = -unroll; i < 0; i++)

  4724     str(value, Address(base, i * 8));

  4725   bind(entry);

  4726   cbnz(cnt, loop);

  4727 }