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
6108 sha1_preserve_prev_abcde(a, b, c, d, e, prev_ab, prev_cd, prev_e);
6109
6110 for (int round = 0; round < 80; round++) {
6111 // prepare K't value
6112 sha1_prepare_k(cur_k, round);
6113
6114 // prepare W't value
6115 sha1_prepare_w(cur_w, ws, buf, round);
6116
6117 // one round process
6118 sha1_process_round(a, b, c, d, e, cur_k, cur_w, t2, round);
6119 }
6120
6121 // compute the intermediate hash value
6122 sha1_calculate_im_hash(a, b, c, d, e, prev_ab, prev_cd, prev_e);
6123
6124 if (multi_block) {
6125 int64_t block_bytes = 16 * 4;
6126 __ addi(buf, buf, block_bytes);
6127
6128 __ bge(limit, buf, L_sha1_loop, true);
6129 }
6130
6131 // store back the state.
6132 __ zext(a, a, 32);
6133 __ slli(b, b, 32);
6134 __ orr(a, a, b);
6135 __ sd(a, Address(state, 0));
6136 __ zext(c, c, 32);
6137 __ slli(d, d, 32);
6138 __ orr(c, c, d);
6139 __ sd(c, Address(state, 8));
6140 __ sw(e, Address(state, 16));
6141
6142 // return offset
6143 if (multi_block) {
6144 __ sub(c_rarg0, buf, src);
6145 }
6146
6147 __ pop_reg(saved_regs, sp);
6148
|
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
6114 sha1_preserve_prev_abcde(a, b, c, d, e, prev_ab, prev_cd, prev_e);
6115
6116 for (int round = 0; round < 80; round++) {
6117 // prepare K't value
6118 sha1_prepare_k(cur_k, round);
6119
6120 // prepare W't value
6121 sha1_prepare_w(cur_w, ws, buf, round);
6122
6123 // one round process
6124 sha1_process_round(a, b, c, d, e, cur_k, cur_w, t2, round);
6125 }
6126
6127 // compute the intermediate hash value
6128 sha1_calculate_im_hash(a, b, c, d, e, prev_ab, prev_cd, prev_e);
6129
6130 if (multi_block) {
6131 int64_t block_bytes = 16 * 4;
6132 __ addi(buf, buf, block_bytes);
6133
6134 __ bge(limit, buf, L_sha1_loop, /* is_far */ true);
6135 }
6136
6137 // store back the state.
6138 __ zext(a, a, 32);
6139 __ slli(b, b, 32);
6140 __ orr(a, a, b);
6141 __ sd(a, Address(state, 0));
6142 __ zext(c, c, 32);
6143 __ slli(d, d, 32);
6144 __ orr(c, c, d);
6145 __ sd(c, Address(state, 8));
6146 __ sw(e, Address(state, 16));
6147
6148 // return offset
6149 if (multi_block) {
6150 __ sub(c_rarg0, buf, src);
6151 }
6152
6153 __ pop_reg(saved_regs, sp);
6154
|