hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp
changeset 35842 1d34635308b0
parent 35840 e77862fd1bcf
child 35951 eb6971bc8c95
equal deleted inserted replaced
35841:39f8dc1df42b 35842:1d34635308b0
  4559   bind(DONE);
  4559   bind(DONE);
  4560 
  4560 
  4561   BLOCK_COMMENT("} string_equals");
  4561   BLOCK_COMMENT("} string_equals");
  4562 }
  4562 }
  4563 
  4563 
       
  4564 
       
  4565 void MacroAssembler::byte_arrays_equals(Register ary1, Register ary2,
       
  4566                                         Register result, Register tmp1)
       
  4567 {
       
  4568   Register cnt1 = rscratch1;
       
  4569   Register cnt2 = rscratch2;
       
  4570   Register tmp2 = rscratch2;
       
  4571 
       
  4572   Label SAME, DIFFER, NEXT, TAIL07, TAIL03, TAIL01;
       
  4573 
       
  4574   int length_offset  = arrayOopDesc::length_offset_in_bytes();
       
  4575   int base_offset    = arrayOopDesc::base_offset_in_bytes(T_BYTE);
       
  4576 
       
  4577   BLOCK_COMMENT("byte_arrays_equals  {");
       
  4578 
       
  4579     // different until proven equal
       
  4580     mov(result, false);
       
  4581 
       
  4582     // same array?
       
  4583     cmp(ary1, ary2);
       
  4584     br(Assembler::EQ, SAME);
       
  4585 
       
  4586     // ne if either null
       
  4587     cbz(ary1, DIFFER);
       
  4588     cbz(ary2, DIFFER);
       
  4589 
       
  4590     // lengths ne?
       
  4591     ldrw(cnt1, Address(ary1, length_offset));
       
  4592     ldrw(cnt2, Address(ary2, length_offset));
       
  4593     cmp(cnt1, cnt2);
       
  4594     br(Assembler::NE, DIFFER);
       
  4595 
       
  4596     lea(ary1, Address(ary1, base_offset));
       
  4597     lea(ary2, Address(ary2, base_offset));
       
  4598 
       
  4599     subs(cnt1, cnt1, 8);
       
  4600     br(LT, TAIL07);
       
  4601 
       
  4602   BIND(NEXT);
       
  4603     ldr(tmp1, Address(post(ary1, 8)));
       
  4604     ldr(tmp2, Address(post(ary2, 8)));
       
  4605     subs(cnt1, cnt1, 8);
       
  4606     eor(tmp1, tmp1, tmp2);
       
  4607     cbnz(tmp1, DIFFER);
       
  4608     br(GE, NEXT);
       
  4609 
       
  4610   BIND(TAIL07);  // 0-7 bytes left, cnt1 = #bytes left - 4
       
  4611     tst(cnt1, 0b100);
       
  4612     br(EQ, TAIL03);
       
  4613     ldrw(tmp1, Address(post(ary1, 4)));
       
  4614     ldrw(tmp2, Address(post(ary2, 4)));
       
  4615     cmp(tmp1, tmp2);
       
  4616     br(NE, DIFFER);
       
  4617 
       
  4618   BIND(TAIL03);  // 0-3 bytes left, cnt1 = #bytes left - 4
       
  4619     tst(cnt1, 0b10);
       
  4620     br(EQ, TAIL01);
       
  4621     ldrh(tmp1, Address(post(ary1, 2)));
       
  4622     ldrh(tmp2, Address(post(ary2, 2)));
       
  4623     cmp(tmp1, tmp2);
       
  4624     br(NE, DIFFER);
       
  4625   BIND(TAIL01);  // 0-1 byte left
       
  4626     tst(cnt1, 0b01);
       
  4627     br(EQ, SAME);
       
  4628     ldrb(tmp1, ary1);
       
  4629     ldrb(tmp2, ary2);
       
  4630     cmp(tmp1, tmp2);
       
  4631     br(NE, DIFFER);
       
  4632 
       
  4633   BIND(SAME);
       
  4634     mov(result, true);
       
  4635   BIND(DIFFER); // result already set
       
  4636 
       
  4637   BLOCK_COMMENT("} byte_arrays_equals");
       
  4638 }
       
  4639 
  4564 // Compare char[] arrays aligned to 4 bytes
  4640 // Compare char[] arrays aligned to 4 bytes
  4565 void MacroAssembler::char_arrays_equals(Register ary1, Register ary2,
  4641 void MacroAssembler::char_arrays_equals(Register ary1, Register ary2,
  4566                                         Register result, Register tmp1)
  4642                                         Register result, Register tmp1)
  4567 {
  4643 {
  4568   Register cnt1 = rscratch1;
  4644   Register cnt1 = rscratch1;