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