src/hotspot/cpu/aarch64/aarch64.ad

*** 16163,16175 ****
    effect(USE_KILL str1, USE_KILL str2, USE_KILL cnt, KILL cr);
  
    format %{ "String Equals $str1,$str2,$cnt -> $result" %}
    ins_encode %{
      // Count is in 8-bit bytes; non-Compact chars are 16 bits.
!     __ arrays_equals($str1$$Register, $str2$$Register,
!                      $result$$Register, $cnt$$Register,
!                      1, /*is_string*/true);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct string_equalsU(iRegP_R1 str1, iRegP_R3 str2, iRegI_R4 cnt,
--- 16163,16174 ----
    effect(USE_KILL str1, USE_KILL str2, USE_KILL cnt, KILL cr);
  
    format %{ "String Equals $str1,$str2,$cnt -> $result" %}
    ins_encode %{
      // Count is in 8-bit bytes; non-Compact chars are 16 bits.
!     __ string_equals($str1$$Register, $str2$$Register,
!                      $result$$Register, $cnt$$Register, 1);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct string_equalsU(iRegP_R1 str1, iRegP_R3 str2, iRegI_R4 cnt,
*** 16180,16225 ****
    effect(USE_KILL str1, USE_KILL str2, USE_KILL cnt, KILL cr);
  
    format %{ "String Equals $str1,$str2,$cnt -> $result" %}
    ins_encode %{
      // Count is in 8-bit bytes; non-Compact chars are 16 bits.
!     __ asrw($cnt$$Register, $cnt$$Register, 1);
!     __ arrays_equals($str1$$Register, $str2$$Register,
!                      $result$$Register, $cnt$$Register,
!                      2, /*is_string*/true);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct array_equalsB(iRegP_R1 ary1, iRegP_R2 ary2, iRegI_R0 result,
                        iRegP_R10 tmp, rFlagsReg cr)
  %{
    predicate(((AryEqNode*)n)->encoding() == StrIntrinsicNode::LL);
    match(Set result (AryEq ary1 ary2));
!   effect(KILL tmp, USE_KILL ary1, USE_KILL ary2, KILL cr);
  
    format %{ "Array Equals $ary1,ary2 -> $result    // KILL $tmp" %}
    ins_encode %{
      __ arrays_equals($ary1$$Register, $ary2$$Register,
!                      $result$$Register, $tmp$$Register,
!                      1, /*is_string*/false);
      %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct array_equalsC(iRegP_R1 ary1, iRegP_R2 ary2, iRegI_R0 result,
                        iRegP_R10 tmp, rFlagsReg cr)
  %{
    predicate(((AryEqNode*)n)->encoding() == StrIntrinsicNode::UU);
    match(Set result (AryEq ary1 ary2));
!   effect(KILL tmp, USE_KILL ary1, USE_KILL ary2, KILL cr);
  
    format %{ "Array Equals $ary1,ary2 -> $result    // KILL $tmp" %}
    ins_encode %{
      __ arrays_equals($ary1$$Register, $ary2$$Register,
!                      $result$$Register, $tmp$$Register,
!                      2, /*is_string*/false);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct has_negatives(iRegP_R1 ary1, iRegI_R2 len, iRegI_R0 result, rFlagsReg cr)
--- 16179,16224 ----
    effect(USE_KILL str1, USE_KILL str2, USE_KILL cnt, KILL cr);
  
    format %{ "String Equals $str1,$str2,$cnt -> $result" %}
    ins_encode %{
      // Count is in 8-bit bytes; non-Compact chars are 16 bits.
!     __ string_equals($str1$$Register, $str2$$Register,
!                      $result$$Register, $cnt$$Register, 2);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct array_equalsB(iRegP_R1 ary1, iRegP_R2 ary2, iRegI_R0 result,
+                        iRegP_R3 tmp1, iRegP_R4 tmp2, iRegP_R5 tmp3,
                         iRegP_R10 tmp, rFlagsReg cr)
  %{
    predicate(((AryEqNode*)n)->encoding() == StrIntrinsicNode::LL);
    match(Set result (AryEq ary1 ary2));
!   effect(KILL tmp, USE_KILL ary1, USE_KILL ary2, TEMP tmp1, TEMP tmp2, TEMP tmp3, KILL cr);
  
    format %{ "Array Equals $ary1,ary2 -> $result    // KILL $tmp" %}
    ins_encode %{
      __ arrays_equals($ary1$$Register, $ary2$$Register,
!                      $tmp1$$Register, $tmp2$$Register, $tmp3$$Register,
!                      $result$$Register, $tmp$$Register, 1);
      %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct array_equalsC(iRegP_R1 ary1, iRegP_R2 ary2, iRegI_R0 result,
+                        iRegP_R3 tmp1, iRegP_R4 tmp2, iRegP_R5 tmp3,
                         iRegP_R10 tmp, rFlagsReg cr)
  %{
    predicate(((AryEqNode*)n)->encoding() == StrIntrinsicNode::UU);
    match(Set result (AryEq ary1 ary2));
!   effect(KILL tmp, USE_KILL ary1, USE_KILL ary2, TEMP tmp1, TEMP tmp2, TEMP tmp3, KILL cr);
  
    format %{ "Array Equals $ary1,ary2 -> $result    // KILL $tmp" %}
    ins_encode %{
      __ arrays_equals($ary1$$Register, $ary2$$Register,
!                      $tmp1$$Register, $tmp2$$Register, $tmp3$$Register,
!                      $result$$Register, $tmp$$Register, 2);
    %}
    ins_pipe(pipe_class_memory);
  %}
  
  instruct has_negatives(iRegP_R1 ary1, iRegI_R2 len, iRegI_R0 result, rFlagsReg cr)