8281146: Replace StringCoding.hasNegatives with countPositives

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -4372,10 +4372,11 @@ address MacroAssembler::count_positives(Register ary1, Register len, Register re
 
   BIND(END);
     ldr(rscratch1, Address(ary1));
-    sub(len, zr, len, LSL, 3); // LSL 3 is to get bits from bytes
-    lslv(rscratch1, rscratch1, len);
+    sub(rscratch2, zr, len, LSL, 3); // LSL 3 is to get bits from bytes
+    lslv(rscratch1, rscratch1, rscratch2);
     tst(rscratch1, UPPER_BIT_MASK);
-    b(SET_RESULT);
+    br(NE, SET_RESULT);
+    b(DONE);
 
   BIND(STUB);
     RuntimeAddress count_pos = RuntimeAddress(StubRoutines::aarch64::count_positives());
@@ -4400,7 +4401,9 @@ address MacroAssembler::count_positives(Register ary1, Register len, Register re
     b(DONE);
 
   BIND(SET_RESULT);
-    csel(result, zr, result, NE); // set len or 0
+
+    add(len, len, wordSize);
+    sub(result, result, len);
 
   BIND(DONE);
   postcond(pc() != badAddress);

src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp

@@ -4674,7 +4674,7 @@ class StubGenerator: public StubCodeGenerator {
     // precondition: a copy of len is already in result
     // __ mov(result, len);
 
-  Label RET_TRUE, RET_TRUE_NO_POP, RET_FALSE, ALIGNED, LOOP16, CHECK_16,
+  Label RET_ADJUST, RET_ADJUST_16, RET_ADJUST_LONG, RET_NO_POP, RET_LEN, ALIGNED, LOOP16, CHECK_16,
         LARGE_LOOP, POST_LOOP16, LEN_OVER_15, LEN_OVER_8, POST_LOOP16_LOAD_TAIL;
 
   __ cmp(len, (u1)15);
@@ -4695,10 +4695,11 @@ class StubGenerator: public StubCodeGenerator {
   __ ldp(rscratch1, rscratch2, Address(ary1, -16));
   __ sub(len, len, 8); // no data dep., then sub can be executed while loading
   __ tst(rscratch2, UPPER_BIT_MASK);
-  __ br(Assembler::NE, RET_TRUE_NO_POP);
+  __ br(Assembler::NE, RET_NO_POP);
   __ sub(rscratch2, zr, len, __ LSL, 3); // LSL 3 is to get bits from bytes
   __ lsrv(rscratch1, rscratch1, rscratch2);
   __ tst(rscratch1, UPPER_BIT_MASK);
+  __ bind(RET_NO_POP);
   __ csel(result, zr, result, Assembler::NE);
   __ leave();
   __ ret(lr);
@@ -4718,10 +4719,10 @@ class StubGenerator: public StubCodeGenerator {
     __ mov(tmp5, 16);
     __ sub(rscratch1, tmp5, rscratch2); // amount of bytes until aligned address
     __ add(ary1, ary1, rscratch1);
-    __ sub(len, len, rscratch1);
     __ orr(tmp6, tmp6, tmp1);
     __ tst(tmp6, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST);
+    __ sub(len, len, rscratch1);
 
   __ bind(ALIGNED);
     __ cmp(len, large_loop_size);
@@ -4736,7 +4737,7 @@ class StubGenerator: public StubCodeGenerator {
     __ sub(len, len, 16);
     __ orr(tmp6, tmp6, tmp1);
     __ tst(tmp6, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST_16);
     __ cmp(len, large_loop_size);
     __ br(Assembler::LT, CHECK_16);
 
@@ -4768,7 +4769,7 @@ class StubGenerator: public StubCodeGenerator {
     __ orr(rscratch1, rscratch1, tmp6);
     __ orr(tmp2, tmp2, rscratch1);
     __ tst(tmp2, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST_LONG);
     __ cmp(len, large_loop_size);
     __ br(Assembler::GE, LARGE_LOOP);
 
@@ -4781,38 +4782,44 @@ class StubGenerator: public StubCodeGenerator {
     __ sub(len, len, 16);
     __ orr(tmp2, tmp2, tmp3);
     __ tst(tmp2, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST_16);
     __ cmp(len, (u1)16);
     __ br(Assembler::GE, LOOP16); // 16-byte load loop end
 
   __ bind(POST_LOOP16); // 16-byte aligned, so we can read unconditionally
     __ cmp(len, (u1)8);
     __ br(Assembler::LE, POST_LOOP16_LOAD_TAIL);
     __ ldr(tmp3, Address(__ post(ary1, 8)));
-    __ sub(len, len, 8);
     __ tst(tmp3, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST);
+    __ sub(len, len, 8);
 
   __ bind(POST_LOOP16_LOAD_TAIL);
-    __ cbz(len, RET_FALSE); // Can't shift left by 64 when len==0
+    __ cbz(len, RET_LEN); // Can't shift left by 64 when len==0
     __ ldr(tmp1, Address(ary1));
     __ mov(tmp2, 64);
     __ sub(tmp4, tmp2, len, __ LSL, 3);
     __ lslv(tmp1, tmp1, tmp4);
     __ tst(tmp1, UPPER_BIT_MASK);
-    __ br(Assembler::NE, RET_TRUE);
+    __ br(Assembler::NE, RET_ADJUST);
     // Fallthrough
 
-  __ bind(RET_FALSE);
+  __ bind(RET_LEN);
     __ pop(spilled_regs, sp);
     __ leave();
     __ ret(lr);
 
-  __ bind(RET_TRUE);
+    // difference result - len is the count of guaranteed to be
+    // positive bytes
+
+  __ bind(RET_ADJUST_LONG);
+    __ add(len, len, (u1)(large_loop_size - 16));
+  __ bind(RET_ADJUST_16);
+    __ add(len, len, 16);
+  __ bind(RET_ADJUST);
     __ pop(spilled_regs, sp);
-  __ bind(RET_TRUE_NO_POP);
     __ leave();
-    __ mov(result, zr);
+    __ sub(result, result, len);
     __ ret(lr);
 
     return entry;

test/micro/org/openjdk/bench/java/lang/StringDecode.java

@@ -87,7 +87,7 @@ public void decodeAsciiShort(Blackhole bh) throws Exception {
         bh.consume(new String(asciiString, charset));
         bh.consume(new String(longAsciiString, 0, 15, charset));
         bh.consume(new String(asciiString, 0, 3, charset));
-        bh.consume(new String(longAsciiString, 512, 512 + 7, charset));
+        bh.consume(new String(longAsciiString, 512, 7, charset));
     }
 
     @Benchmark
@@ -103,7 +103,7 @@ public void decodeLatin1Short(Blackhole bh) throws Exception {
         bh.consume(new String(latin1String, charset));
         bh.consume(new String(latin1String, 0, 15, charset));
         bh.consume(new String(latin1String, 0, 3, charset));
-        bh.consume(new String(longLatin1OnlyString, 512, 512 + 7, charset));
+        bh.consume(new String(longLatin1OnlyString, 512, 7, charset));
     }
 
     @Benchmark