1907 // Load layout helper (32-bits)
1908 //
1909 // |array_tag| | header_size | element_type | |log2_element_size|
1910 // 32 30 24 16 8 2 0
1911 //
1912 // array_tag: typeArray = 0x3, objArray = 0x2, non-array = 0x0
1913 //
1914
1915 const int lh_offset = in_bytes(Klass::layout_helper_offset());
1916
1917 // Handle objArrays completely differently...
1918 const jint objArray_lh = Klass::array_layout_helper(T_OBJECT);
1919 __ lw(lh, Address(scratch_src_klass, lh_offset));
1920 __ mv(t0, objArray_lh);
1921 __ beq(lh, t0, L_objArray);
1922
1923 // if [src->klass() != dst->klass()] then return -1
1924 __ load_klass(t1, dst);
1925 __ bne(t1, scratch_src_klass, L_failed);
1926
1927 // if src->is_Array() isn't null then return -1
1928 // i.e. (lh >= 0)
1929 __ bgez(lh, L_failed);
1930
1931 // At this point, it is known to be a typeArray (array_tag 0x3).
1932 #ifdef ASSERT
1933 {
1934 BLOCK_COMMENT("assert primitive array {");
1935 Label L;
1936 __ mv(t1, (int32_t)(Klass::_lh_array_tag_type_value << Klass::_lh_array_tag_shift));
1937 __ bge(lh, t1, L);
1938 __ stop("must be a primitive array");
1939 __ bind(L);
1940 BLOCK_COMMENT("} assert primitive array done");
1941 }
1942 #endif
1943
1944 arraycopy_range_checks(src, src_pos, dst, dst_pos, scratch_length,
1945 t1, L_failed);
1946
5983 sha1_preserve_prev_abcde(a, b, c, d, e, prev_ab, prev_cd, prev_e);
5984
5985 for (int round = 0; round < 80; round++) {
5986 // prepare K't value
5987 sha1_prepare_k(cur_k, round);
5988
5989 // prepare W't value
5990 sha1_prepare_w(cur_w, ws, buf, round);
5991
5992 // one round process
5993 sha1_process_round(a, b, c, d, e, cur_k, cur_w, t2, round);
5994 }
5995
5996 // compute the intermediate hash value
5997 sha1_calculate_im_hash(a, b, c, d, e, prev_ab, prev_cd, prev_e);
5998
5999 if (multi_block) {
6000 int64_t block_bytes = 16 * 4;
6001 __ addi(buf, buf, block_bytes);
6002
6003 __ bge(limit, buf, L_sha1_loop, true);
6004 }
6005
6006 // store back the state.
6007 __ zext(a, a, 32);
6008 __ slli(b, b, 32);
6009 __ orr(a, a, b);
6010 __ sd(a, Address(state, 0));
6011 __ zext(c, c, 32);
6012 __ slli(d, d, 32);
6013 __ orr(c, c, d);
6014 __ sd(c, Address(state, 8));
6015 __ sw(e, Address(state, 16));
6016
6017 // return offset
6018 if (multi_block) {
6019 __ sub(c_rarg0, buf, src);
6020 }
6021
6022 __ pop_reg(saved_regs, sp);
6023
|
1907 // Load layout helper (32-bits)
1908 //
1909 // |array_tag| | header_size | element_type | |log2_element_size|
1910 // 32 30 24 16 8 2 0
1911 //
1912 // array_tag: typeArray = 0x3, objArray = 0x2, non-array = 0x0
1913 //
1914
1915 const int lh_offset = in_bytes(Klass::layout_helper_offset());
1916
1917 // Handle objArrays completely differently...
1918 const jint objArray_lh = Klass::array_layout_helper(T_OBJECT);
1919 __ lw(lh, Address(scratch_src_klass, lh_offset));
1920 __ mv(t0, objArray_lh);
1921 __ beq(lh, t0, L_objArray);
1922
1923 // if [src->klass() != dst->klass()] then return -1
1924 __ load_klass(t1, dst);
1925 __ bne(t1, scratch_src_klass, L_failed);
1926
1927 // Check for flat inline type array -> return -1
1928 __ test_flat_array_oop(src, t1, L_failed);
1929
1930 // Check for null-free (non-flat) inline type array -> handle as object array
1931 __ test_null_free_array_oop(src, t1, L_objArray);
1932
1933 // if src->is_Array() isn't null then return -1
1934 // i.e. (lh >= 0)
1935 __ bgez(lh, L_failed);
1936
1937 // At this point, it is known to be a typeArray (array_tag 0x3).
1938 #ifdef ASSERT
1939 {
1940 BLOCK_COMMENT("assert primitive array {");
1941 Label L;
1942 __ mv(t1, (int32_t)(Klass::_lh_array_tag_type_value << Klass::_lh_array_tag_shift));
1943 __ bge(lh, t1, L);
1944 __ stop("must be a primitive array");
1945 __ bind(L);
1946 BLOCK_COMMENT("} assert primitive array done");
1947 }
1948 #endif
1949
1950 arraycopy_range_checks(src, src_pos, dst, dst_pos, scratch_length,
1951 t1, L_failed);
1952
5989 sha1_preserve_prev_abcde(a, b, c, d, e, prev_ab, prev_cd, prev_e);
5990
5991 for (int round = 0; round < 80; round++) {
5992 // prepare K't value
5993 sha1_prepare_k(cur_k, round);
5994
5995 // prepare W't value
5996 sha1_prepare_w(cur_w, ws, buf, round);
5997
5998 // one round process
5999 sha1_process_round(a, b, c, d, e, cur_k, cur_w, t2, round);
6000 }
6001
6002 // compute the intermediate hash value
6003 sha1_calculate_im_hash(a, b, c, d, e, prev_ab, prev_cd, prev_e);
6004
6005 if (multi_block) {
6006 int64_t block_bytes = 16 * 4;
6007 __ addi(buf, buf, block_bytes);
6008
6009 __ bge(limit, buf, L_sha1_loop, /* is_far */ true);
6010 }
6011
6012 // store back the state.
6013 __ zext(a, a, 32);
6014 __ slli(b, b, 32);
6015 __ orr(a, a, b);
6016 __ sd(a, Address(state, 0));
6017 __ zext(c, c, 32);
6018 __ slli(d, d, 32);
6019 __ orr(c, c, d);
6020 __ sd(c, Address(state, 8));
6021 __ sw(e, Address(state, 16));
6022
6023 // return offset
6024 if (multi_block) {
6025 __ sub(c_rarg0, buf, src);
6026 }
6027
6028 __ pop_reg(saved_regs, sp);
6029
|