8374351: RISC-V: Small refactoring for crypto macro-assembler routines

Reviewed-by: fyang, fjiang

Author: Anjian Wen

src/hotspot/cpu/riscv/stubGenerator_riscv.cpp

@@ -2436,7 +2436,7 @@ class StubGenerator: public StubCodeGenerator {
     StubRoutines::_unsafe_setmemory    = generate_unsafe_setmemory();
   }
 
-  void generate_aes_loadkeys(const Register &key, VectorRegister *working_vregs, int rounds) {
+  void aes_load_keys(const Register &key, VectorRegister *working_vregs, int rounds) {
     const int step = 16;
     for (int i = 0; i < rounds; i++) {
       __ vle32_v(working_vregs[i], key);
@@ -2448,7 +2448,7 @@ class StubGenerator: public StubCodeGenerator {
     }
   }
 
-  void generate_aes_encrypt(const VectorRegister &res, VectorRegister *working_vregs, int rounds) {
+  void aes_encrypt(const VectorRegister &res, VectorRegister *working_vregs, int rounds) {
     assert(rounds <= 15, "rounds should be less than or equal to working_vregs size");
 
     __ vxor_vv(res, res, working_vregs[0]);
@@ -2499,26 +2499,26 @@ class StubGenerator: public StubCodeGenerator {
     // Else we fallthrough to the biggest case (256-bit key size)
 
     // Note: the following function performs key += 15*16
-    generate_aes_loadkeys(key, working_vregs, 15);
-    generate_aes_encrypt(res, working_vregs, 15);
+    aes_load_keys(key, working_vregs, 15);
+    aes_encrypt(res, working_vregs, 15);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
     __ ret();
 
   __ bind(L_aes192);
     // Note: the following function performs key += 13*16
-    generate_aes_loadkeys(key, working_vregs, 13);
-    generate_aes_encrypt(res, working_vregs, 13);
+    aes_load_keys(key, working_vregs, 13);
+    aes_encrypt(res, working_vregs, 13);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
     __ ret();
 
   __ bind(L_aes128);
     // Note: the following function performs key += 11*16
-    generate_aes_loadkeys(key, working_vregs, 11);
-    generate_aes_encrypt(res, working_vregs, 11);
+    aes_load_keys(key, working_vregs, 11);
+    aes_encrypt(res, working_vregs, 11);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
@@ -2527,7 +2527,7 @@ class StubGenerator: public StubCodeGenerator {
     return start;
   }
 
-  void generate_aes_decrypt(const VectorRegister &res, VectorRegister *working_vregs, int rounds) {
+  void aes_decrypt(const VectorRegister &res, VectorRegister *working_vregs, int rounds) {
     assert(rounds <= 15, "rounds should be less than or equal to working_vregs size");
 
     __ vxor_vv(res, res, working_vregs[rounds - 1]);
@@ -2578,26 +2578,26 @@ class StubGenerator: public StubCodeGenerator {
     // Else we fallthrough to the biggest case (256-bit key size)
 
     // Note: the following function performs key += 15*16
-    generate_aes_loadkeys(key, working_vregs, 15);
-    generate_aes_decrypt(res, working_vregs, 15);
+    aes_load_keys(key, working_vregs, 15);
+    aes_decrypt(res, working_vregs, 15);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
     __ ret();
 
   __ bind(L_aes192);
     // Note: the following function performs key += 13*16
-    generate_aes_loadkeys(key, working_vregs, 13);
-    generate_aes_decrypt(res, working_vregs, 13);
+    aes_load_keys(key, working_vregs, 13);
+    aes_decrypt(res, working_vregs, 13);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
     __ ret();
 
   __ bind(L_aes128);
     // Note: the following function performs key += 11*16
-    generate_aes_loadkeys(key, working_vregs, 11);
-    generate_aes_decrypt(res, working_vregs, 11);
+    aes_load_keys(key, working_vregs, 11);
+    aes_decrypt(res, working_vregs, 11);
     __ vse32_v(res, to);
     __ mv(c_rarg0, 0);
     __ leave();
@@ -2622,14 +2622,14 @@ class StubGenerator: public StubCodeGenerator {
     __ vsetivli(x0, 4, Assembler::e32, Assembler::m1);
     __ vle32_v(v16, rvec);
 
-    generate_aes_loadkeys(key, working_vregs, round);
+    aes_load_keys(key, working_vregs, round);
     Label L_enc_loop;
     __ bind(L_enc_loop);
     // Encrypt from source by block size
       __ vle32_v(v17, from);
       __ addi(from, from, BLOCK_SIZE);
       __ vxor_vv(v16, v16, v17);
-      generate_aes_encrypt(v16, working_vregs, round);
+      aes_encrypt(v16, working_vregs, round);
       __ vse32_v(v16, to);
       __ addi(to, to, BLOCK_SIZE);
       __ subi(len, len, BLOCK_SIZE);
@@ -2709,14 +2709,14 @@ class StubGenerator: public StubCodeGenerator {
     __ vsetivli(x0, 4, Assembler::e32, Assembler::m1);
     __ vle32_v(v16, rvec);
 
-    generate_aes_loadkeys(key, working_vregs, round);
+    aes_load_keys(key, working_vregs, round);
     Label L_dec_loop;
     // Decrypt from source by block size
     __ bind(L_dec_loop);
       __ vle32_v(v17, from);
       __ addi(from, from, BLOCK_SIZE);
       __ vmv_v_v(v18, v17);
-      generate_aes_decrypt(v17, working_vregs, round);
+      aes_decrypt(v17, working_vregs, round);
       __ vxor_vv(v17, v17, v16);
       __ vse32_v(v17, to);
       __ vmv_v_v(v16, v18);
@@ -2811,7 +2811,7 @@ class StubGenerator: public StubCodeGenerator {
                             Register input_len,  Register saved_encrypted_ctr, Register used_ptr) {
     // Algorithm:
     //
-    //   generate_aes_loadkeys();
+    //   aes_load_keys();
     //   load_counter_128(counter_hi, counter_lo, counter);
     //
     //   L_next:
@@ -2825,7 +2825,7 @@ class StubGenerator: public StubCodeGenerator {
     //
     //   L_main_loop:
     //     if (len == 0) goto L_exit;
-    //     saved_encrypted_ctr = generate_aes_encrypt(counter);
+    //     saved_encrypted_ctr = aes_encrypt(counter);
     //
     //     add_counter_128(counter_hi, counter_lo);
     //     be_store_counter_128(counter_hi, counter_lo, counter);
@@ -2869,7 +2869,7 @@ class StubGenerator: public StubCodeGenerator {
     __ mv(block_size, BLOCK_SIZE);
 
     // load keys to working_vregs according to round
-    generate_aes_loadkeys(key, working_vregs, round);
+    aes_load_keys(key, working_vregs, round);
 
     // 128-bit big-endian load
     be_load_counter_128(counter_hi, counter_lo, counter);
@@ -2902,7 +2902,7 @@ class StubGenerator: public StubCodeGenerator {
     __ vle32_v(v16, counter);
 
     // encrypt counter according to round
-    generate_aes_encrypt(v16, working_vregs, round);
+    aes_encrypt(v16, working_vregs, round);
 
     __ vse32_v(v16, saved_encrypted_ctr);
 
@@ -2997,6 +2997,34 @@ class StubGenerator: public StubCodeGenerator {
     return start;
   }
 
+  void ghash_loop(Register state, Register subkeyH, Register data, Register blocks,
+                  VectorRegister vtmp1, VectorRegister vtmp2, VectorRegister vtmp3) {
+    VectorRegister partial_hash = vtmp1;
+    VectorRegister hash_subkey  = vtmp2;
+    VectorRegister cipher_text  = vtmp3;
+
+    const unsigned int BLOCK_SIZE = 16;
+
+    __ vsetivli(x0, 2, Assembler::e64, Assembler::m1);
+    __ vle64_v(hash_subkey, subkeyH);
+    __ vrev8_v(hash_subkey, hash_subkey);
+    __ vle64_v(partial_hash, state);
+    __ vrev8_v(partial_hash, partial_hash);
+
+    __ vsetivli(x0, 4, Assembler::e32, Assembler::m1);
+    Label L_ghash_loop;
+    __ bind(L_ghash_loop);
+      __ vle32_v(cipher_text, data);
+      __ addi(data, data, BLOCK_SIZE);
+      __ vghsh_vv(partial_hash, hash_subkey, cipher_text);
+      __ subi(blocks, blocks, 1);
+      __ bnez(blocks, L_ghash_loop);
+
+    __ vsetivli(x0, 2, Assembler::e64, Assembler::m1);
+    __ vrev8_v(partial_hash, partial_hash);
+    __ vse64_v(partial_hash, state);
+  }
+
   /**
    *  Arguments:
    *
@@ -3024,30 +3052,12 @@ class StubGenerator: public StubCodeGenerator {
     Register data    = c_rarg2;
     Register blocks  = c_rarg3;
 
-    VectorRegister partial_hash = v1;
-    VectorRegister hash_subkey  = v2;
-    VectorRegister cipher_text  = v3;
+    VectorRegister vtmp1 = v1;
+    VectorRegister vtmp2 = v2;
+    VectorRegister vtmp3 = v3;
 
-    const unsigned int BLOCK_SIZE = 16;
+    ghash_loop(state, subkeyH, data, blocks, vtmp1, vtmp2, vtmp3);
 
-    __ vsetivli(x0, 2, Assembler::e64, Assembler::m1);
-    __ vle64_v(hash_subkey, subkeyH);
-    __ vrev8_v(hash_subkey, hash_subkey);
-    __ vle64_v(partial_hash, state);
-    __ vrev8_v(partial_hash, partial_hash);
-
-    __ vsetivli(x0, 4, Assembler::e32, Assembler::m1);
-    Label L_ghash_loop;
-    __ bind(L_ghash_loop);
-      __ vle32_v(cipher_text, data);
-      __ addi(data, data, BLOCK_SIZE);
-      __ vghsh_vv(partial_hash, hash_subkey, cipher_text);
-      __ subi(blocks, blocks, 1);
-      __ bnez(blocks, L_ghash_loop);
-
-    __ vsetivli(x0, 2, Assembler::e64, Assembler::m1);
-    __ vrev8_v(partial_hash, partial_hash);
-    __ vse64_v(partial_hash, state);
     __ leave();
     __ ret();